From 7cef83f85854f7f8616f27add2c1ca494ebbe8dd Mon Sep 17 00:00:00 2001 From: Jurgen Lentz Date: Sat, 6 Jul 2024 19:24:51 +0200 Subject: [PATCH] add pyscipopt as source --- pyproject.toml | 7 - setup.py | 22 +- src/pyscipopt/Multidict.py | 21 + src/pyscipopt/__init__.py | 47 + src/pyscipopt/_version.py | 1 + src/pyscipopt/benders.pxi | 212 + src/pyscipopt/benderscut.pxi | 77 + src/pyscipopt/branchrule.pxi | 103 + src/pyscipopt/conshdlr.pxi | 478 + src/pyscipopt/cutsel.pxi | 99 + src/pyscipopt/event.pxi | 88 + src/pyscipopt/expr.pxi | 677 + src/pyscipopt/heuristic.pxi | 79 + src/pyscipopt/lp.pxi | 456 + src/pyscipopt/nodesel.pxi | 101 + src/pyscipopt/presol.pxi | 93 + src/pyscipopt/pricer.pxi | 90 + src/pyscipopt/propagator.pxi | 163 + src/pyscipopt/reader.pxi | 64 + src/pyscipopt/recipes/README.md | 6 + src/pyscipopt/recipes/__init__.py | 0 src/pyscipopt/recipes/infeasibilities.py | 50 + src/pyscipopt/recipes/nonlinear.py | 18 + src/pyscipopt/recipes/piecewise.py | 39 + src/pyscipopt/relax.pxi | 80 + src/pyscipopt/scip.c | 270321 ++++++++++++++++++++ src/pyscipopt/scip.pxd | 1961 + src/pyscipopt/scip.pxi | 5453 + src/pyscipopt/scip.pyx | 3 + src/pyscipopt/sepa.pxi | 91 + tests/test_pricing_solver.py | 178 + 31 files changed, 281066 insertions(+), 12 deletions(-) create mode 100644 src/pyscipopt/Multidict.py create mode 100644 src/pyscipopt/__init__.py create mode 100644 src/pyscipopt/_version.py create mode 100644 src/pyscipopt/benders.pxi create mode 100644 src/pyscipopt/benderscut.pxi create mode 100644 src/pyscipopt/branchrule.pxi create mode 100644 src/pyscipopt/conshdlr.pxi create mode 100644 src/pyscipopt/cutsel.pxi create mode 100644 src/pyscipopt/event.pxi create mode 100644 src/pyscipopt/expr.pxi create mode 100644 src/pyscipopt/heuristic.pxi create mode 100644 src/pyscipopt/lp.pxi create mode 100644 src/pyscipopt/nodesel.pxi create mode 100644 src/pyscipopt/presol.pxi create mode 100644 src/pyscipopt/pricer.pxi create mode 100644 src/pyscipopt/propagator.pxi create mode 100644 src/pyscipopt/reader.pxi create mode 100644 src/pyscipopt/recipes/README.md create mode 100644 src/pyscipopt/recipes/__init__.py create mode 100644 src/pyscipopt/recipes/infeasibilities.py create mode 100644 src/pyscipopt/recipes/nonlinear.py create mode 100644 src/pyscipopt/recipes/piecewise.py create mode 100644 src/pyscipopt/relax.pxi create mode 100644 src/pyscipopt/scip.c create mode 100644 src/pyscipopt/scip.pxd create mode 100644 src/pyscipopt/scip.pxi create mode 100644 src/pyscipopt/scip.pyx create mode 100644 src/pyscipopt/sepa.pxi create mode 100644 tests/test_pricing_solver.py diff --git a/pyproject.toml b/pyproject.toml index 464d34e..347acff 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -48,13 +48,6 @@ before-all = [ "unzip gcg.zip", "mv scip_install gcg" ] -before-build = [ - "pip install cython", - "wget https://github.com/scipopt/pyscipopt/archive/refs/tags/v5.1.1.zip -O pyscipopt.zip", - "unzip pyscipopt.zip", - "cd PySCIPOpt-5.1.1", - "python setup.py install" -] environment = { SCIPOPTDIR="$(pwd)/gcg", GCGOPTDIR="$(pwd)/gcg", LD_LIBRARY_PATH="$(pwd)/gcg/lib:$LD_LIBRARY_PATH", DYLD_LIBRARY_PATH="$(pwd)/gcg/lib:$DYLD_LIBRARY_PATH", PATH="$(pwd)/gcg/bin:$PATH", PKG_CONFIG_PATH="$(pwd)/gcg/lib/pkgconfig:$PKG_CONFIG_PATH", RELEASE="true"} diff --git a/setup.py b/setup.py index 52b343f..e0180b8 100644 --- a/setup.py +++ b/setup.py @@ -66,9 +66,10 @@ use_cython = True -packagedir = os.path.join('src', 'pygcgopt') +packagedirscip = os.path.join('src', 'pyscipopt') +packagedirgcg = os.path.join('src', 'pygcgopt') -with open(os.path.join(packagedir, '__init__.py'), 'r') as initfile: +with open(os.path.join(packagedirgcg, '__init__.py'), 'r') as initfile: version = re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', initfile.read(), re.MULTILINE).group(1) @@ -80,14 +81,25 @@ quit(1) use_cython = False -if not os.path.exists(os.path.join(packagedir, 'gcg.pyx')): +if not os.path.exists(os.path.join(packagedirgcg, 'gcg.pyx')): use_cython = False ext = '.pyx' if use_cython else '.cpp' extra_compile_args.append("-std=c++11") -extensions = [Extension('pygcgopt.gcg', [os.path.join(packagedir, 'gcg'+ext)], +on_github_actions = os.getenv('GITHUB_ACTIONS') == 'true' +release_mode = os.getenv('RELEASE') == 'true' +compile_with_line_tracing = on_github_actions and not release_mode + +extensions = [Extension("pyscipopt.scip", [os.path.join(packagedirscip, f"scip{ext}")], + include_dirs=includedirs, + library_dirs=[sciplibdir], + libraries=[sciplibname], + extra_compile_args=extra_compile_args, + extra_link_args=extra_link_args, + define_macros= [("CYTHON_TRACE_NOGIL", 1), ("CYTHON_TRACE", 1)] if compile_with_line_tracing else []), + Extension('pygcgopt.gcg', [os.path.join(packagedirgcg, 'gcg'+ext)], include_dirs=includedirs, library_dirs=list(set([sciplibdir, gcglibdir])), libraries=[sciplibname, gcglibname], @@ -126,6 +138,6 @@ 'pyscipopt>=5.1.0' ], packages=['pygcgopt'], - package_dir={'pygcgopt': packagedir}, + package_dir={'pygcgopt': packagedirgcg}, package_data = {'pygcgopt': ['gcg.pyx', 'gcg.pxd', '*.pxi', 'gcg/lib/*']} ) diff --git a/src/pyscipopt/Multidict.py b/src/pyscipopt/Multidict.py new file mode 100644 index 0000000..07bafa5 --- /dev/null +++ b/src/pyscipopt/Multidict.py @@ -0,0 +1,21 @@ +##@file Multidict.py +#@brief Implementation of Multidictionaries +def multidict(D): + '''creates a multidictionary''' + keys = list(D.keys()) + if len(keys) == 0: + return [[]] + try: + N = len(D[keys[0]]) + islist = True + except: + N = 1 + islist = False + dlist = [dict() for d in range(N)] + for k in keys: + if islist: + for i in range(N): + dlist[i][k] = D[k][i] + else: + dlist[0][k] = D[k] + return [keys]+dlist diff --git a/src/pyscipopt/__init__.py b/src/pyscipopt/__init__.py new file mode 100644 index 0000000..a370c60 --- /dev/null +++ b/src/pyscipopt/__init__.py @@ -0,0 +1,47 @@ +from ._version import __version__ + +# required for Python 3.8 on Windows +import os +if hasattr(os, 'add_dll_directory'): + if os.getenv('SCIPOPTDIR'): + os.add_dll_directory(os.path.join(os.getenv('SCIPOPTDIR').strip('"'), 'bin')) + +# export user-relevant objects: +from pyscipopt.Multidict import multidict +from pyscipopt.scip import Model +from pyscipopt.scip import Variable +from pyscipopt.scip import Constraint +from pyscipopt.scip import Benders +from pyscipopt.scip import Benderscut +from pyscipopt.scip import Branchrule +from pyscipopt.scip import Nodesel +from pyscipopt.scip import Conshdlr +from pyscipopt.scip import Eventhdlr +from pyscipopt.scip import Heur +from pyscipopt.scip import Presol +from pyscipopt.scip import Pricer +from pyscipopt.scip import Prop +from pyscipopt.scip import Reader +from pyscipopt.scip import Sepa +from pyscipopt.scip import LP +from pyscipopt.scip import Expr +from pyscipopt.scip import quicksum +from pyscipopt.scip import quickprod +from pyscipopt.scip import exp +from pyscipopt.scip import log +from pyscipopt.scip import sqrt +from pyscipopt.scip import sin +from pyscipopt.scip import cos +from pyscipopt.scip import PY_SCIP_RESULT as SCIP_RESULT +from pyscipopt.scip import PY_SCIP_PARAMSETTING as SCIP_PARAMSETTING +from pyscipopt.scip import PY_SCIP_PARAMEMPHASIS as SCIP_PARAMEMPHASIS +from pyscipopt.scip import PY_SCIP_STATUS as SCIP_STATUS +from pyscipopt.scip import PY_SCIP_STAGE as SCIP_STAGE +from pyscipopt.scip import PY_SCIP_PROPTIMING as SCIP_PROPTIMING +from pyscipopt.scip import PY_SCIP_PRESOLTIMING as SCIP_PRESOLTIMING +from pyscipopt.scip import PY_SCIP_HEURTIMING as SCIP_HEURTIMING +from pyscipopt.scip import PY_SCIP_EVENTTYPE as SCIP_EVENTTYPE +from pyscipopt.scip import PY_SCIP_LPSOLSTAT as SCIP_LPSOLSTAT +from pyscipopt.scip import PY_SCIP_BRANCHDIR as SCIP_BRANCHDIR +from pyscipopt.scip import PY_SCIP_BENDERSENFOTYPE as SCIP_BENDERSENFOTYPE +from pyscipopt.scip import PY_SCIP_ROWORIGINTYPE as SCIP_ROWORIGINTYPE diff --git a/src/pyscipopt/_version.py b/src/pyscipopt/_version.py new file mode 100644 index 0000000..40f5033 --- /dev/null +++ b/src/pyscipopt/_version.py @@ -0,0 +1 @@ +__version__ = '5.1.1' diff --git a/src/pyscipopt/benders.pxi b/src/pyscipopt/benders.pxi new file mode 100644 index 0000000..66a394d --- /dev/null +++ b/src/pyscipopt/benders.pxi @@ -0,0 +1,212 @@ +##@file benders.pxi +#@brief Base class of the Benders decomposition Plugin +cdef class Benders: + cdef public Model model + cdef public str name + cdef SCIP_BENDERS* _benders + + def bendersfree(self): + '''calls destructor and frees memory of Benders decomposition ''' + pass + + def bendersinit(self): + '''initializes Benders deconposition''' + pass + + def bendersexit(self): + '''calls exit method of Benders decomposition''' + pass + + def bendersinitpre(self): + '''informs the Benders decomposition that the presolving process is being started ''' + pass + + def bendersexitpre(self): + '''informs the Benders decomposition that the presolving process has been completed''' + pass + + def bendersinitsol(self): + '''informs Benders decomposition that the branch and bound process is being started ''' + pass + + def bendersexitsol(self): + '''informs Benders decomposition that the branch and bound process data is being freed''' + pass + + def benderscreatesub(self, probnumber): + '''creates the subproblems and registers it with the Benders decomposition struct ''' + print("python error in benderscreatesub: this method needs to be implemented") + return {} + + def benderspresubsolve(self, solution, enfotype, checkint): + '''sets the pre subproblem solve callback of Benders decomposition ''' + return {} + + def benderssolvesubconvex(self, solution, probnumber, onlyconvex): + '''sets convex solve callback of Benders decomposition''' + return {} + + def benderssolvesub(self, solution, probnumber): + '''sets solve callback of Benders decomposition ''' + return {} + + def benderspostsolve(self, solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible): + '''sets post-solve callback of Benders decomposition ''' + return {} + + def bendersfreesub(self, probnumber): + '''frees the subproblems''' + pass + + def bendersgetvar(self, variable, probnumber): + '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. ''' + print("python error in bendersgetvar: this method needs to be implemented") + return {} + +# local helper functions for the interface +cdef Variable getPyVar(SCIP_VAR* var): + cdef SCIP_VARDATA* vardata + vardata = SCIPvarGetData(var) + return vardata + + +cdef SCIP_RETCODE PyBendersCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_Bool threadsafe) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersFree (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.bendersfree() + Py_DECREF(PyBenders) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersInit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.bendersinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersExit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.bendersexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersInitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.bendersinitpre() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersExitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.bendersexitpre() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersInitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.bendersinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersExitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.bendersexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersCreatesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.benderscreatesub(probnumber) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersPresubsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint, SCIP_Bool* infeasible, SCIP_Bool* auxviol, SCIP_Bool* skipsolve, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + if sol == NULL: + solution = None + else: + solution = Solution.create(scip, sol) + enfotype = type + result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) + infeasible[0] = result_dict.get("infeasible", False) + auxviol[0] = result_dict.get("auxviol", False) + skipsolve[0] = result_dict.get("skipsolve", False) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersSolvesubconvex (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Bool onlyconvex, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + if sol == NULL: + solution = None + else: + solution = Solution.create(scip, sol) + result_dict = PyBenders.benderssolvesubconvex(solution, probnumber, onlyconvex) + objective[0] = result_dict.get("objective", 1e+20) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersSolvesub (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + if sol == NULL: + solution = None + else: + solution = Solution.create(scip, sol) + result_dict = PyBenders.benderssolvesub(solution, probnumber) + objective[0] = result_dict.get("objective", 1e+20) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersPostsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, + SCIP_BENDERSENFOTYPE type, int* mergecands, int npriomergecands, int nmergecands, SCIP_Bool checkint, + SCIP_Bool infeasible, SCIP_Bool* merged) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + if sol == NULL: + solution = None + else: + solution = Solution.create(scip, sol) + enfotype = type + mergecandidates = [] + for i in range(nmergecands): + mergecandidates.append(mergecands[i]) + result_dict = PyBenders.benderspostsolve(solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible) + merged[0] = result_dict.get("merged", False) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBendersFreesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyBenders.bendersfreesub(probnumber) + return SCIP_OKAY + +#TODO: Really need to ask about the passing and returning of variables +cdef SCIP_RETCODE PyBendersGetvar (SCIP* scip, SCIP_BENDERS* benders, SCIP_VAR* var, SCIP_VAR** mappedvar, int probnumber) noexcept with gil: + cdef SCIP_BENDERSDATA* bendersdata + bendersdata = SCIPbendersGetData(benders) + PyBenders = bendersdata + PyVar = getPyVar(var) + result_dict = PyBenders.bendersgetvar(PyVar, probnumber) + mappedvariable = (result_dict.get("mappedvar", None)) + if mappedvariable is None: + mappedvar[0] = NULL + else: + mappedvar[0] = mappedvariable.scip_var + return SCIP_OKAY diff --git a/src/pyscipopt/benderscut.pxi b/src/pyscipopt/benderscut.pxi new file mode 100644 index 0000000..1ce561a --- /dev/null +++ b/src/pyscipopt/benderscut.pxi @@ -0,0 +1,77 @@ +##@file benderscut.pxi +#@brief Base class of the Benderscut Plugin +cdef class Benderscut: + cdef public Model model + cdef public Benders benders + cdef public str name + + def benderscutfree(self): + pass + + def benderscutinit(self): + pass + + def benderscutexit(self): + pass + + def benderscutinitsol(self): + pass + + def benderscutexitsol(self): + pass + + def benderscutexec(self, solution, probnumber, enfotype): + print("python error in benderscutexec: this method needs to be implemented") + return {} + +cdef SCIP_RETCODE PyBenderscutCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyBenderscutFree (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + cdef SCIP_BENDERSCUTDATA* benderscutdata + benderscutdata = SCIPbenderscutGetData(benderscut) + PyBenderscut = benderscutdata + PyBenderscut.benderscutfree() + Py_DECREF(PyBenderscut) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBenderscutInit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + cdef SCIP_BENDERSCUTDATA* benderscutdata + benderscutdata = SCIPbenderscutGetData(benderscut) + PyBenderscut = benderscutdata + PyBenderscut.benderscutinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBenderscutExit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + cdef SCIP_BENDERSCUTDATA* benderscutdata + benderscutdata = SCIPbenderscutGetData(benderscut) + PyBenderscut = benderscutdata + PyBenderscut.benderscutexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBenderscutInitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + cdef SCIP_BENDERSCUTDATA* benderscutdata + benderscutdata = SCIPbenderscutGetData(benderscut) + PyBenderscut = benderscutdata + PyBenderscut.benderscutinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBenderscutExitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + cdef SCIP_BENDERSCUTDATA* benderscutdata + benderscutdata = SCIPbenderscutGetData(benderscut) + PyBenderscut = benderscutdata + PyBenderscut.benderscutexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBenderscutExec (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut, SCIP_SOL* sol, int probnumber, SCIP_BENDERSENFOTYPE type, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_BENDERSCUTDATA* benderscutdata + benderscutdata = SCIPbenderscutGetData(benderscut) + PyBenderscut = benderscutdata + if sol == NULL: + solution = None + else: + solution = Solution.create(scip, sol) + enfotype = type + result_dict = PyBenderscut.benderscutexec(solution, probnumber, enfotype) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY diff --git a/src/pyscipopt/branchrule.pxi b/src/pyscipopt/branchrule.pxi new file mode 100644 index 0000000..2d3411d --- /dev/null +++ b/src/pyscipopt/branchrule.pxi @@ -0,0 +1,103 @@ +##@file branchrule.pxi +#@brief Base class of the Branchrule Plugin +cdef class Branchrule: + cdef public Model model + + def branchfree(self): + '''frees memory of branching rule''' + pass + + def branchinit(self): + '''initializes branching rule''' + pass + + def branchexit(self): + '''deinitializes branching rule''' + pass + + def branchinitsol(self): + '''informs branching rule that the branch and bound process is being started ''' + pass + + def branchexitsol(self): + '''informs branching rule that the branch and bound process data is being freed''' + pass + + def branchexeclp(self, allowaddcons): + '''executes branching rule for fractional LP solution''' + raise NotImplementedError("branchexeclp() is a fundamental callback and should be implemented in the derived " + "class") + + def branchexecext(self, allowaddcons): + '''executes branching rule for external branching candidates ''' + raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") + + def branchexecps(self, allowaddcons): + '''executes branching rule for not completely fixed pseudo solution ''' + # this method needs to be implemented by the user + raise NotImplementedError("branchexecps() is a fundamental callback and should be implemented in the derived class") + + + +cdef SCIP_RETCODE PyBranchruleCopy (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyBranchruleFree (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + cdef SCIP_BRANCHRULEDATA* branchruledata + branchruledata = SCIPbranchruleGetData(branchrule) + PyBranchrule = branchruledata + PyBranchrule.branchfree() + Py_DECREF(PyBranchrule) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBranchruleInit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + cdef SCIP_BRANCHRULEDATA* branchruledata + branchruledata = SCIPbranchruleGetData(branchrule) + PyBranchrule = branchruledata + PyBranchrule.branchinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBranchruleExit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + cdef SCIP_BRANCHRULEDATA* branchruledata + branchruledata = SCIPbranchruleGetData(branchrule) + PyBranchrule = branchruledata + PyBranchrule.branchexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBranchruleInitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + cdef SCIP_BRANCHRULEDATA* branchruledata + branchruledata = SCIPbranchruleGetData(branchrule) + PyBranchrule = branchruledata + PyBranchrule.branchinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBranchruleExitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + cdef SCIP_BRANCHRULEDATA* branchruledata + branchruledata = SCIPbranchruleGetData(branchrule) + PyBranchrule = branchruledata + PyBranchrule.branchexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyBranchruleExeclp (SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_BRANCHRULEDATA* branchruledata + branchruledata = SCIPbranchruleGetData(branchrule) + PyBranchrule = branchruledata + result_dict = PyBranchrule.branchexeclp(allowaddcons) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBranchruleExecext(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_BRANCHRULEDATA* branchruledata + branchruledata = SCIPbranchruleGetData(branchrule) + PyBranchrule = branchruledata + result_dict = PyBranchrule.branchexecext(allowaddcons) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyBranchruleExecps(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_BRANCHRULEDATA* branchruledata + branchruledata = SCIPbranchruleGetData(branchrule) + PyBranchrule = branchruledata + result_dict = PyBranchrule.branchexecps(allowaddcons) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY diff --git a/src/pyscipopt/conshdlr.pxi b/src/pyscipopt/conshdlr.pxi new file mode 100644 index 0000000..2071778 --- /dev/null +++ b/src/pyscipopt/conshdlr.pxi @@ -0,0 +1,478 @@ +##@file conshdlr.pxi +#@brief base class of the Constraint Handler plugin + +cdef class Conshdlr: + cdef public Model model + cdef public str name + + def consfree(self): + '''calls destructor and frees memory of constraint handler ''' + pass + + def consinit(self, constraints): + '''calls initialization method of constraint handler ''' + pass + + def consexit(self, constraints): + '''calls exit method of constraint handler ''' + pass + + def consinitpre(self, constraints): + '''informs constraint handler that the presolving process is being started ''' + pass + + def consexitpre(self, constraints): + '''informs constraint handler that the presolving is finished ''' + pass + + def consinitsol(self, constraints): + '''informs constraint handler that the branch and bound process is being started ''' + pass + + def consexitsol(self, constraints, restart): + '''informs constraint handler that the branch and bound process data is being freed ''' + pass + + def consdelete(self, constraint): + '''sets method of constraint handler to free specific constraint data ''' + pass + + def constrans(self, sourceconstraint): + '''sets method of constraint handler to transform constraint data into data belonging to the transformed problem ''' + return {} + + def consinitlp(self, constraints): + '''calls LP initialization method of constraint handler to separate all initial active constraints ''' + return {} + + def conssepalp(self, constraints, nusefulconss): + '''calls separator method of constraint handler to separate LP solution ''' + return {} + + def conssepasol(self, constraints, nusefulconss, solution): + '''calls separator method of constraint handler to separate given primal solution ''' + return {} + + def consenfolp(self, constraints, nusefulconss, solinfeasible): + '''calls enforcing method of constraint handler for LP solution for all constraints added''' + print("python error in consenfolp: this method needs to be implemented") + return {} + + def consenforelax(self, solution, constraints, nusefulconss, solinfeasible): + '''calls enforcing method of constraint handler for a relaxation solution for all constraints added''' + print("python error in consenforelax: this method needs to be implemented") + return {} + + def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible): + '''calls enforcing method of constraint handler for pseudo solution for all constraints added''' + print("python error in consenfops: this method needs to be implemented") + return {} + + def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely): + '''calls feasibility check method of constraint handler ''' + print("python error in conscheck: this method needs to be implemented") + return {} + + def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming): + '''calls propagation method of constraint handler ''' + return {} + + def conspresol(self, constraints, nrounds, presoltiming, + nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict): + '''calls presolving method of constraint handler ''' + return result_dict + + def consresprop(self): + '''sets propagation conflict resolving method of constraint handler ''' + return {} + + def conslock(self, constraint, locktype, nlockspos, nlocksneg): + '''variable rounding lock method of constraint handler''' + print("python error in conslock: this method needs to be implemented") + return {} + + def consactive(self, constraint): + '''sets activation notification method of constraint handler ''' + pass + + def consdeactive(self, constraint): + '''sets deactivation notification method of constraint handler ''' + pass + + def consenable(self, constraint): + '''sets enabling notification method of constraint handler ''' + pass + + def consdisable(self, constraint): + '''sets disabling notification method of constraint handler ''' + pass + + def consdelvars(self, constraints): + '''calls variable deletion method of constraint handler''' + pass + + def consprint(self, constraint): + '''sets constraint display method of constraint handler ''' + pass + + def conscopy(self): + '''sets copy method of both the constraint handler and each associated constraint''' + pass + + def consparse(self): + '''sets constraint parsing method of constraint handler ''' + pass + + def consgetvars(self, constraint): + '''sets constraint variable getter method of constraint handler''' + pass + + def consgetnvars(self, constraint): + '''sets constraint variable number getter method of constraint handler ''' + return {} + + def consgetdivebdchgs(self): + '''calls diving solution enforcement callback of constraint handler, if it exists ''' + pass + + def consgetpermsymgraph(self): + '''permutation symmetry detection graph getter callback, if it exists ''' + pass + + def consgetsignedpermsymgraph(self): + '''signed permutation symmetry detection graph getter callback, if it exists ''' + pass + + +# local helper functions for the interface +cdef Conshdlr getPyConshdlr(SCIP_CONSHDLR* conshdlr): + cdef SCIP_CONSHDLRDATA* conshdlrdata + conshdlrdata = SCIPconshdlrGetData(conshdlr) + return conshdlrdata + +cdef Constraint getPyCons(SCIP_CONS* cons): + cdef SCIP_CONSDATA* consdata + consdata = SCIPconsGetData(cons) + return consdata + + + +cdef SCIP_RETCODE PyConshdlrCopy (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyConshdlr.consfree() + Py_DECREF(PyConshdlr) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + PyConshdlr.consinit(constraints) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + PyConshdlr.consexit(constraints) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + PyConshdlr.consinitpre(constraints) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + PyConshdlr.consexitpre(constraints) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + PyConshdlr.consinitsol(constraints) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + PyConshdlr.consexitsol(constraints, restart) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsDelete (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyCons = getPyCons(cons) + assert consdata[0] == PyCons + PyConshdlr.consdelete(PyCons) + consdata[0] = NULL + Py_DECREF(PyCons) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons) noexcept with gil: + cdef Constraint PyTargetCons + PyConshdlr = getPyConshdlr(conshdlr) + PySourceCons = getPyCons(sourcecons) + result_dict = PyConshdlr.constrans(PySourceCons) + + # create target (transform) constraint: if user doesn't return a constraint, copy PySourceCons + # otherwise use the created cons + if "targetcons" in result_dict: + PyTargetCons = result_dict.get("targetcons") + targetcons[0] = PyTargetCons.scip_cons + Py_INCREF(PyTargetCons) + else: + PY_SCIP_CALL(SCIPcreateCons(scip, targetcons, str_conversion(PySourceCons.name), conshdlr, PySourceCons, + PySourceCons.isInitial(), PySourceCons.isSeparated(), PySourceCons.isEnforced(), PySourceCons.isChecked(), + PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(), + PySourceCons.isRemovable(), PySourceCons.isStickingAtNode())) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + result_dict = PyConshdlr.consinitlp(constraints) + infeasible[0] = result_dict.get("infeasible", infeasible[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + result_dict = PyConshdlr.conssepalp(constraints, nusefulconss) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + SCIP_SOL* sol, SCIP_RESULT* result) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + solution = Solution.create(scip, sol) + result_dict = PyConshdlr.conssepasol(constraints, nusefulconss, solution) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +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: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + solution = Solution.create(scip, sol) + result_dict = PyConshdlr.consenforelax(solution, constraints, nusefulconss, solinfeasible) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality, + SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + solution = Solution.create(scip, sol) + result_dict = PyConshdlr.conscheck(constraints, solution, checkintegrality, checklprows, printreason, completely) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss, + SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming, + int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes, + int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + # dictionary for input/output parameters + result_dict = {} + result_dict["nfixedvars"] = nfixedvars[0] + result_dict["naggrvars"] = naggrvars[0] + result_dict["nchgvartypes"] = nchgvartypes[0] + result_dict["nchgbds"] = nchgbds[0] + result_dict["naddholes"] = naddholes[0] + result_dict["ndelconss"] = ndelconss[0] + result_dict["naddconss"] = naddconss[0] + result_dict["nupgdconss"] = nupgdconss[0] + result_dict["nchgcoefs"] = nchgcoefs[0] + result_dict["nchgsides"] = nchgsides[0] + result_dict["result"] = result[0] + PyConshdlr.conspresol(constraints, nrounds, presoltiming, + nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + result[0] = result_dict["result"] + nfixedvars[0] = result_dict["nfixedvars"] + naggrvars[0] = result_dict["naggrvars"] + nchgvartypes[0] = result_dict["nchgvartypes"] + nchgbds[0] = result_dict["nchgbds"] + naddholes[0] = result_dict["naddholes"] + ndelconss[0] = result_dict["ndelconss"] + naddconss[0] = result_dict["naddconss"] + nupgdconss[0] = result_dict["nupgdconss"] + nchgcoefs[0] = result_dict["nchgcoefs"] + nchgsides[0] = result_dict["nchgsides"] + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsResprop (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR* infervar, int inferinfo, + SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyConshdlr.consresprop() + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + if cons == NULL: + PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg) + else: + PyCons = getPyCons(cons) + PyConshdlr.conslock(PyCons, locktype, nlockspos, nlocksneg) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyCons = getPyCons(cons) + PyConshdlr.consactive(PyCons) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsDeactive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyCons = getPyCons(cons) + PyConshdlr.consdeactive(PyCons) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsEnable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyCons = getPyCons(cons) + PyConshdlr.consenable(PyCons) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyCons = getPyCons(cons) + PyConshdlr.consdisable(PyCons) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + cdef constraints = [] + for i in range(nconss): + constraints.append(getPyCons(conss[i])) + PyConshdlr.consdelvars(constraints) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsPrint (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyCons = getPyCons(cons) + # TODO: pass file + PyConshdlr.consprint(PyCons) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsCopy (SCIP* scip, SCIP_CONS** cons, const char* name, SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr, + SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, 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, + SCIP_Bool isglobal, SCIP_Bool* valid) noexcept with gil: + # TODO everything! + PyConshdlr = getPyConshdlr(sourceconshdlr) + PyConshdlr.conscopy() + valid[0] = False + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsParse (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, const char* name, const char* str, + 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, SCIP_Bool* success) noexcept with gil: + # TODO everything! + PyConshdlr = getPyConshdlr(conshdlr) + PyConshdlr.consparse() + success[0] = False + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsGetvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success) noexcept with gil: + # TODO + PyConshdlr = getPyConshdlr(conshdlr) + PyCons = getPyCons(cons) + PyConshdlr.consgetvars(PyCons) + success[0] = False + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsGetnvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success) noexcept with gil: + PyConshdlr = getPyConshdlr(conshdlr) + PyCons = getPyCons(cons) + result_dict = PyConshdlr.consgetnvars(PyCons) + nvars[0] = result_dict.get("nvars", 0) + success[0] = result_dict.get("success", False) + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsGetdivebdchgs (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, SCIP_SOL* sol, + SCIP_Bool* success, SCIP_Bool* infeasible) noexcept with gil: + # TODO + PyConshdlr = getPyConshdlr(conshdlr) + PyConshdlr.consgetdivebdchgs() + success[0] = False + infeasible[0] = False + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsGetPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, + SCIP_Bool* success) noexcept with gil: + # TODO + PyConshdlr = getPyConshdlr(conshdlr) + PyConshdlr.consgetpermsymgraph() + success[0] = False + return SCIP_OKAY + +cdef SCIP_RETCODE PyConsGetSignedPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, + SCIP_Bool* success) noexcept with gil: + # TODO + PyConshdlr = getPyConshdlr(conshdlr) + PyConshdlr.consgetsignedpermsymgraph() + success[0] = False + return SCIP_OKAY diff --git a/src/pyscipopt/cutsel.pxi b/src/pyscipopt/cutsel.pxi new file mode 100644 index 0000000..d259fb2 --- /dev/null +++ b/src/pyscipopt/cutsel.pxi @@ -0,0 +1,99 @@ +##@file cutsel.pxi +#@brief Base class of the Cutsel Plugin +cdef class Cutsel: + cdef public Model model + + def cutselfree(self): + '''frees memory of cut selector''' + pass + + def cutselinit(self): + ''' executed after the problem is transformed. use this call to initialize cut selector data.''' + pass + + def cutselexit(self): + '''executed before the transformed problem is freed''' + pass + + def cutselinitsol(self): + '''executed when the presolving is finished and the branch-and-bound process is about to begin''' + pass + + def cutselexitsol(self): + '''executed before the branch-and-bound process is freed''' + pass + + def cutselselect(self, cuts, forcedcuts, root, maxnselectedcuts): + '''first method called in each iteration in the main solving loop. ''' + # this method needs to be implemented by the user + return {} + + +cdef SCIP_RETCODE PyCutselCopy (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyCutselFree (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + cdef SCIP_CUTSELDATA* cutseldata + cutseldata = SCIPcutselGetData(cutsel) + PyCutsel = cutseldata + PyCutsel.cutselfree() + Py_DECREF(PyCutsel) + return SCIP_OKAY + +cdef SCIP_RETCODE PyCutselInit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + cdef SCIP_CUTSELDATA* cutseldata + cutseldata = SCIPcutselGetData(cutsel) + PyCutsel = cutseldata + PyCutsel.cutselinit() + return SCIP_OKAY + + +cdef SCIP_RETCODE PyCutselExit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + cdef SCIP_CUTSELDATA* cutseldata + cutseldata = SCIPcutselGetData(cutsel) + PyCutsel = cutseldata + PyCutsel.cutselexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyCutselInitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + cdef SCIP_CUTSELDATA* cutseldata + cutseldata = SCIPcutselGetData(cutsel) + PyCutsel = cutseldata + PyCutsel.cutselinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyCutselExitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + cdef SCIP_CUTSELDATA* cutseldata + cutseldata = SCIPcutselGetData(cutsel) + PyCutsel = cutseldata + PyCutsel.cutselexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyCutselSelect (SCIP* scip, SCIP_CUTSEL* cutsel, SCIP_ROW** cuts, int ncuts, + SCIP_ROW** forcedcuts, int nforcedcuts, SCIP_Bool root, int maxnselectedcuts, + int* nselectedcuts, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_CUTSELDATA* cutseldata + cdef SCIP_ROW* scip_row + cutseldata = SCIPcutselGetData(cutsel) + PyCutsel = cutseldata + + # translate cuts to python + pycuts = [Row.create(cuts[i]) for i in range(ncuts)] + pyforcedcuts = [Row.create(forcedcuts[i]) for i in range(nforcedcuts)] + result_dict = PyCutsel.cutselselect(pycuts, pyforcedcuts, root, maxnselectedcuts) + + # Retrieve the sorted cuts. Note that these do not need to be returned explicitly in result_dict. + # Pycuts could have been sorted in place in cutselselect() + pycuts = result_dict.get('cuts', pycuts) + + assert len(pycuts) == ncuts + assert len(pyforcedcuts) == nforcedcuts + + #sort cuts + for i,cut in enumerate(pycuts): + cuts[i] = ((cut).scip_row) + + nselectedcuts[0] = result_dict.get('nselectedcuts', 0) + result[0] = result_dict.get('result', result[0]) + + return SCIP_OKAY diff --git a/src/pyscipopt/event.pxi b/src/pyscipopt/event.pxi new file mode 100644 index 0000000..914e882 --- /dev/null +++ b/src/pyscipopt/event.pxi @@ -0,0 +1,88 @@ +##@file event.pxi +#@brief Base class of the Event Handler Plugin +cdef class Eventhdlr: + cdef public Model model + cdef public str name + + def eventcopy(self): + '''sets copy callback for all events of this event handler ''' + pass + + def eventfree(self): + '''calls destructor and frees memory of event handler ''' + pass + + def eventinit(self): + '''initializes event handler''' + pass + + def eventexit(self): + '''calls exit method of event handler''' + pass + + def eventinitsol(self): + '''informs event handler that the branch and bound process is being started ''' + pass + + def eventexitsol(self): + '''informs event handler that the branch and bound process data is being freed ''' + pass + + def eventdelete(self): + '''sets callback to free specific event data''' + pass + + def eventexec(self, event): + '''calls execution method of event handler ''' + print("python error in eventexec: this method needs to be implemented") + return {} + + +# local helper functions for the interface +cdef Eventhdlr getPyEventhdlr(SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + cdef SCIP_EVENTHDLRDATA* eventhdlrdata + eventhdlrdata = SCIPeventhdlrGetData(eventhdlr) + return eventhdlrdata + +cdef SCIP_RETCODE PyEventCopy (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + PyEventhdlr = getPyEventhdlr(eventhdlr) + PyEventhdlr.eventcopy() + return SCIP_OKAY + +cdef SCIP_RETCODE PyEventFree (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + PyEventhdlr = getPyEventhdlr(eventhdlr) + PyEventhdlr.eventfree() + Py_DECREF(PyEventhdlr) + return SCIP_OKAY + +cdef SCIP_RETCODE PyEventInit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + PyEventhdlr = getPyEventhdlr(eventhdlr) + PyEventhdlr.eventinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyEventExit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + PyEventhdlr = getPyEventhdlr(eventhdlr) + PyEventhdlr.eventexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyEventInitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + PyEventhdlr = getPyEventhdlr(eventhdlr) + PyEventhdlr.eventinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyEventExitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + PyEventhdlr = getPyEventhdlr(eventhdlr) + PyEventhdlr.eventexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyEventDelete (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENTDATA** eventdata) noexcept with gil: + PyEventhdlr = getPyEventhdlr(eventhdlr) + PyEventhdlr.eventdelete() + return SCIP_OKAY + +cdef SCIP_RETCODE PyEventExec (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENT* event, SCIP_EVENTDATA* eventdata) noexcept with gil: + PyEventhdlr = getPyEventhdlr(eventhdlr) + PyEvent = Event() + PyEvent.event = event + PyEventhdlr.eventexec(PyEvent) + return SCIP_OKAY diff --git a/src/pyscipopt/expr.pxi b/src/pyscipopt/expr.pxi new file mode 100644 index 0000000..aac1981 --- /dev/null +++ b/src/pyscipopt/expr.pxi @@ -0,0 +1,677 @@ +##@file expr.pxi +#@brief In this file we implemenet the handling of expressions +#@details @anchor ExprDetails 
 We have two types of expressions: Expr and GenExpr.
+# The Expr can only handle polynomial expressions.
+# In addition, one can recover easily information from them.
+# A polynomial is a dictionary between `terms` and coefficients.
+# A `term` is a tuple of variables
+# For examples, 2*x*x*y*z - 1.3 x*y*y + 1 is stored as a
+# {Term(x,x,y,z) : 2, Term(x,y,y) : -1.3, Term() : 1}
+# Addition of common terms and expansion of exponents occur automatically.
+# Given the way `Expr`s are stored, it is easy to access the terms: e.g.
+# expr = 2*x*x*y*z - 1.3 x*y*y + 1
+# expr[Term(x,x,y,z)] returns 1.3
+# expr[Term(x)] returns 0.0
+#
+# On the other hand, when dealing with expressions more general than polynomials,
+# that is, absolute values, exp, log, sqrt or any general exponent, we use GenExpr.
+# GenExpr stores expression trees in a rudimentary way.
+# Basically, it stores the operator and the list of children.
+# We have different types of general expressions that in addition
+# to the operation and list of children stores
+# SumExpr: coefficients and constant
+# ProdExpr: constant
+# Constant: constant
+# VarExpr: variable
+# PowExpr: exponent
+# UnaryExpr: nothing
+# We do not provide any way of accessing the internal information of the expression tree,
+# nor we simplify common terms or do any other type of simplification.
+# The `GenExpr` is pass as is to SCIP and SCIP will do what it see fits during presolving.
+#
+# TODO: All this is very complicated, so we might wanna unify Expr and GenExpr.
+# Maybe when consexpr is released it makes sense to revisit this.
+# TODO: We have to think about the operations that we define: __isub__, __add__, etc
+# and when to copy expressions and when to not copy them.
+# For example: when creating a ExprCons from an Expr expr, we store the expression expr
+# and then we normalize. When doing the normalization, we do
+# ```
+# c = self.expr[CONST]
+# self.expr -= c
+# ```
+# which should, in princple, modify the expr. However, since we do not implement __isub__, __sub__
+# gets called (I guess) and so a copy is returned.
+# Modifying the expression directly would be a bug, given that the expression might be re-used by the user.
+ + +def _is_number(e): + try: + f = float(e) + return True + except ValueError: # for malformed strings + return False + except TypeError: # for other types (Variable, Expr) + return False + + +def _expr_richcmp(self, other, op): + if op == 1: # <= + if isinstance(other, Expr) or isinstance(other, GenExpr): + return (self - other) <= 0.0 + elif _is_number(other): + return ExprCons(self, rhs=float(other)) + else: + raise NotImplementedError + elif op == 5: # >= + if isinstance(other, Expr) or isinstance(other, GenExpr): + return (self - other) >= 0.0 + elif _is_number(other): + return ExprCons(self, lhs=float(other)) + else: + raise NotImplementedError + elif op == 2: # == + if isinstance(other, Expr) or isinstance(other, GenExpr): + return (self - other) == 0.0 + elif _is_number(other): + return ExprCons(self, lhs=float(other), rhs=float(other)) + else: + raise NotImplementedError + else: + raise NotImplementedError("Can only support constraints with '<=', '>=', or '=='.") + + +class Term: + '''This is a monomial term''' + + __slots__ = ('vartuple', 'ptrtuple', 'hashval') + + def __init__(self, *vartuple): + self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + self.hashval = sum(self.ptrtuple) + + def __getitem__(self, idx): + return self.vartuple[idx] + + def __hash__(self): + return self.hashval + + def __eq__(self, other): + return self.ptrtuple == other.ptrtuple + + def __len__(self): + return len(self.vartuple) + + def __add__(self, other): + both = self.vartuple + other.vartuple + return Term(*both) + + def __repr__(self): + return 'Term(%s)' % ', '.join([str(v) for v in self.vartuple]) + + +CONST = Term() + +# helper function +def buildGenExprObj(expr): + """helper function to generate an object of type GenExpr""" + if _is_number(expr): + return Constant(expr) + elif isinstance(expr, Expr): + # loop over terms and create a sumexpr with the sum of each term + # each term is either a variable (which gets transformed into varexpr) + # or a product of variables (which gets tranformed into a prod) + sumexpr = SumExpr() + for vars, coef in expr.terms.items(): + if len(vars) == 0: + sumexpr += coef + elif len(vars) == 1: + varexpr = VarExpr(vars[0]) + sumexpr += coef * varexpr + else: + prodexpr = ProdExpr() + for v in vars: + varexpr = VarExpr(v) + prodexpr *= varexpr + sumexpr += coef * prodexpr + return sumexpr + else: + assert isinstance(expr, GenExpr) + return expr + +##@details Polynomial expressions of variables with operator overloading. \n +#See also the @ref ExprDetails "description" in the expr.pxi. +cdef class Expr: + + def __init__(self, terms=None): + '''terms is a dict of variables to coefficients. + + CONST is used as key for the constant term.''' + self.terms = {} if terms is None else terms + + if len(self.terms) == 0: + self.terms[CONST] = 0.0 + + def __getitem__(self, key): + if not isinstance(key, Term): + key = Term(key) + return self.terms.get(key, 0.0) + + def __iter__(self): + return iter(self.terms) + + def __next__(self): + try: return next(self.terms) + except: raise StopIteration + + def __abs__(self): + return abs(buildGenExprObj(self)) + + def __add__(self, other): + left = self + right = other + + if _is_number(self): + assert isinstance(other, Expr) + left,right = right,left + terms = left.terms.copy() + + if isinstance(right, Expr): + # merge the terms by component-wise addition + for v,c in right.terms.items(): + terms[v] = terms.get(v, 0.0) + c + elif _is_number(right): + c = float(right) + terms[CONST] = terms.get(CONST, 0.0) + c + elif isinstance(right, GenExpr): + return buildGenExprObj(left) + right + else: + raise NotImplementedError + return Expr(terms) + + def __iadd__(self, other): + if isinstance(other, Expr): + for v,c in other.terms.items(): + self.terms[v] = self.terms.get(v, 0.0) + c + elif _is_number(other): + c = float(other) + self.terms[CONST] = self.terms.get(CONST, 0.0) + c + elif isinstance(other, GenExpr): + # is no longer in place, might affect performance? + # can't do `self = buildGenExprObj(self) + other` since I get + # TypeError: Cannot convert pyscipopt.scip.SumExpr to pyscipopt.scip.Expr + return buildGenExprObj(self) + other + else: + raise NotImplementedError + return self + + def __mul__(self, other): + if _is_number(other): + f = float(other) + return Expr({v:f*c for v,c in self.terms.items()}) + elif _is_number(self): + f = float(self) + return Expr({v:f*c for v,c in other.terms.items()}) + elif isinstance(other, Expr): + terms = {} + for v1, c1 in self.terms.items(): + for v2, c2 in other.terms.items(): + v = v1 + v2 + terms[v] = terms.get(v, 0.0) + c1 * c2 + return Expr(terms) + elif isinstance(other, GenExpr): + return buildGenExprObj(self) * other + else: + raise NotImplementedError + + def __truediv__(self,other): + if _is_number(other): + f = 1.0/float(other) + return f * self + selfexpr = buildGenExprObj(self) + return selfexpr.__truediv__(other) + + def __rtruediv__(self, other): + ''' other / self ''' + if _is_number(self): + f = 1.0/float(self) + return f * other + otherexpr = buildGenExprObj(other) + return otherexpr.__truediv__(self) + + def __pow__(self, other, modulo): + if float(other).is_integer() and other >= 0: + exp = int(other) + else: # need to transform to GenExpr + return buildGenExprObj(self)**other + + res = 1 + for _ in range(exp): + res *= self + return res + + def __neg__(self): + return Expr({v:-c for v,c in self.terms.items()}) + + def __sub__(self, other): + return self + (-other) + + def __radd__(self, other): + return self.__add__(other) + + def __rmul__(self, other): + return self.__mul__(other) + + def __rsub__(self, other): + return -1.0 * self + other + + def __richcmp__(self, other, op): + '''turn it into a constraint''' + return _expr_richcmp(self, other, op) + + def normalize(self): + '''remove terms with coefficient of 0''' + self.terms = {t:c for (t,c) in self.terms.items() if c != 0.0} + + def __repr__(self): + return 'Expr(%s)' % repr(self.terms) + + def degree(self): + '''computes highest degree of terms''' + if len(self.terms) == 0: + return 0 + else: + return max(len(v) for v in self.terms) + + +cdef class ExprCons: + '''Constraints with a polynomial expressions and lower/upper bounds.''' + cdef public expr + cdef public _lhs + cdef public _rhs + + def __init__(self, expr, lhs=None, rhs=None): + self.expr = expr + self._lhs = lhs + self._rhs = rhs + assert not (lhs is None and rhs is None) + self.normalize() + + def normalize(self): + '''move constant terms in expression to bounds''' + if isinstance(self.expr, Expr): + c = self.expr[CONST] + self.expr -= c + assert self.expr[CONST] == 0.0 + self.expr.normalize() + else: + assert isinstance(self.expr, GenExpr) + return + + if not self._lhs is None: + self._lhs -= c + if not self._rhs is None: + self._rhs -= c + + + def __richcmp__(self, other, op): + '''turn it into a constraint''' + if op == 1: # <= + if not self._rhs is None: + raise TypeError('ExprCons already has upper bound') + assert self._rhs is None + assert not self._lhs is None + + if not _is_number(other): + raise TypeError('Ranged ExprCons is not well defined!') + + return ExprCons(self.expr, lhs=self._lhs, rhs=float(other)) + elif op == 5: # >= + if not self._lhs is None: + raise TypeError('ExprCons already has lower bound') + assert self._lhs is None + assert not self._rhs is None + + if not _is_number(other): + raise TypeError('Ranged ExprCons is not well defined!') + + return ExprCons(self.expr, lhs=float(other), rhs=self._rhs) + else: + raise TypeError + + def __repr__(self): + return 'ExprCons(%s, %s, %s)' % (self.expr, self._lhs, self._rhs) + + def __nonzero__(self): + '''Make sure that equality of expressions is not asserted with ==''' + + msg = """Can't evaluate constraints as booleans. + +If you want to add a ranged constraint of the form + lhs <= expression <= rhs +you have to use parenthesis to break the Python syntax for chained comparisons: + lhs <= (expression <= rhs) +""" + raise TypeError(msg) + +def quicksum(termlist): + '''add linear expressions and constants much faster than Python's sum + by avoiding intermediate data structures and adding terms inplace + ''' + result = Expr() + for term in termlist: + result += term + return result + +def quickprod(termlist): + '''multiply linear expressions and constants by avoiding intermediate + data structures and multiplying terms inplace + ''' + result = Expr() + 1 + for term in termlist: + result *= term + return result + + +class Op: + const = 'const' + varidx = 'var' + exp, log, sqrt, sin, cos = 'exp', 'log', 'sqrt', 'sin', 'cos' + plus, minus, mul, div, power = '+', '-', '*', '/', '**' + add = 'sum' + prod = 'prod' + fabs = 'abs' + +Operator = Op() + +##@details 
 General expressions of variables with operator overloading.
+#
+#@note
+#   - these expressions are not smart enough to identify equal terms
+#   - in contrast to polynomial expressions, __getitem__ is not implemented
+#     so expr[x] will generate an error instead of returning the coefficient of x
+# +#See also the @ref ExprDetails "description" in the expr.pxi. +cdef class GenExpr: + cdef public _op + cdef public children + + + def __init__(self): # do we need it + ''' ''' + + def __abs__(self): + return UnaryExpr(Operator.fabs, self) + + def __add__(self, other): + left = buildGenExprObj(self) + right = buildGenExprObj(other) + ans = SumExpr() + + # add left term + if left.getOp() == Operator.add: + ans.coefs.extend(left.coefs) + ans.children.extend(left.children) + ans.constant += left.constant + elif left.getOp() == Operator.const: + ans.constant += left.number + else: + ans.coefs.append(1.0) + ans.children.append(left) + + # add right term + if right.getOp() == Operator.add: + ans.coefs.extend(right.coefs) + ans.children.extend(right.children) + ans.constant += right.constant + elif right.getOp() == Operator.const: + ans.constant += right.number + else: + ans.coefs.append(1.0) + ans.children.append(right) + + return ans + + #def __iadd__(self, other): + #''' in-place addition, i.e., expr += other ''' + # assert isinstance(self, Expr) + # right = buildGenExprObj(other) + # + # # transform self into sum + # if self.getOp() != Operator.add: + # newsum = SumExpr() + # if self.getOp() == Operator.const: + # newsum.constant += self.number + # else: + # newsum.coefs.append(1.0) + # newsum.children.append(self.copy()) # TODO: what is copy? + # self = newsum + # # add right term + # if right.getOp() == Operator.add: + # self.coefs.extend(right.coefs) + # self.children.extend(right.children) + # self.constant += right.constant + # elif right.getOp() == Operator.const: + # self.constant += right.number + # else: + # self.coefs.append(1.0) + # self.children.append(right) + # return self + + def __mul__(self, other): + left = buildGenExprObj(self) + right = buildGenExprObj(other) + ans = ProdExpr() + + # multiply left factor + if left.getOp() == Operator.prod: + ans.children.extend(left.children) + ans.constant *= left.constant + elif left.getOp() == Operator.const: + ans.constant *= left.number + else: + ans.children.append(left) + + # multiply right factor + if right.getOp() == Operator.prod: + ans.children.extend(right.children) + ans.constant *= right.constant + elif right.getOp() == Operator.const: + ans.constant *= right.number + else: + ans.children.append(right) + + return ans + + #def __imul__(self, other): + #''' in-place multiplication, i.e., expr *= other ''' + # assert isinstance(self, Expr) + # right = buildGenExprObj(other) + # # transform self into prod + # if self.getOp() != Operator.prod: + # newprod = ProdExpr() + # if self.getOp() == Operator.const: + # newprod.constant *= self.number + # else: + # newprod.children.append(self.copy()) # TODO: what is copy? + # self = newprod + # # multiply right factor + # if right.getOp() == Operator.prod: + # self.children.extend(right.children) + # self.constant *= right.constant + # elif right.getOp() == Operator.const: + # self.constant *= right.number + # else: + # self.children.append(right) + # return self + + def __pow__(self, other, modulo): + expo = buildGenExprObj(other) + if expo.getOp() != Operator.const: + raise NotImplementedError("exponents must be numbers") + if self.getOp() == Operator.const: + return Constant(self.number**expo.number) + ans = PowExpr() + ans.children.append(self) + ans.expo = expo.number + + return ans + + #TODO: ipow, idiv, etc + def __truediv__(self,other): + divisor = buildGenExprObj(other) + # we can't divide by 0 + if divisor.getOp() == Operator.const and divisor.number == 0.0: + raise ZeroDivisionError("cannot divide by 0") + return self * divisor**(-1) + + def __rtruediv__(self, other): + ''' other / self ''' + otherexpr = buildGenExprObj(other) + return otherexpr.__truediv__(self) + + def __neg__(self): + return -1.0 * self + + def __sub__(self, other): + return self + (-other) + + def __radd__(self, other): + return self.__add__(other) + + def __rmul__(self, other): + return self.__mul__(other) + + def __rsub__(self, other): + return -1.0 * self + other + + def __richcmp__(self, other, op): + '''turn it into a constraint''' + return _expr_richcmp(self, other, op) + + def degree(self): + '''Note: none of these expressions should be polynomial''' + return float('inf') + + def getOp(self): + '''returns operator of GenExpr''' + return self._op + + +# Sum Expressions +cdef class SumExpr(GenExpr): + + cdef public constant + cdef public coefs + + def __init__(self): + self.constant = 0.0 + self.coefs = [] + self.children = [] + self._op = Operator.add + def __repr__(self): + return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + +# Prod Expressions +cdef class ProdExpr(GenExpr): + cdef public constant + def __init__(self): + self.constant = 1.0 + self.children = [] + self._op = Operator.prod + def __repr__(self): + return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + +# Var Expressions +cdef class VarExpr(GenExpr): + cdef public var + def __init__(self, var): + self.children = [var] + self._op = Operator.varidx + def __repr__(self): + return self.children[0].__repr__() + +# Pow Expressions +cdef class PowExpr(GenExpr): + cdef public expo + def __init__(self): + self.expo = 1.0 + self.children = [] + self._op = Operator.power + def __repr__(self): + return self._op + "(" + self.children[0].__repr__() + "," + str(self.expo) + ")" + +# Exp, Log, Sqrt, Sin, Cos Expressions +cdef class UnaryExpr(GenExpr): + def __init__(self, op, expr): + self.children = [] + self.children.append(expr) + self._op = op + def __repr__(self): + return self._op + "(" + self.children[0].__repr__() + ")" + +# class for constant expressions +cdef class Constant(GenExpr): + cdef public number + def __init__(self,number): + self.number = number + self._op = Operator.const + + def __repr__(self): + return str(self.number) + +def exp(expr): + """returns expression with exp-function""" + return UnaryExpr(Operator.exp, buildGenExprObj(expr)) +def log(expr): + """returns expression with log-function""" + return UnaryExpr(Operator.log, buildGenExprObj(expr)) +def sqrt(expr): + """returns expression with sqrt-function""" + return UnaryExpr(Operator.sqrt, buildGenExprObj(expr)) +def sin(expr): + """returns expression with sin-function""" + return UnaryExpr(Operator.sin, buildGenExprObj(expr)) +def cos(expr): + """returns expression with cos-function""" + return UnaryExpr(Operator.cos, buildGenExprObj(expr)) + +def expr_to_nodes(expr): + '''transforms tree to an array of nodes. each node is an operator and the position of the + children of that operator (i.e. the other nodes) in the array''' + assert isinstance(expr, GenExpr) + nodes = [] + expr_to_array(expr, nodes) + return nodes + +def value_to_array(val, nodes): + """adds a given value to an array""" + nodes.append(tuple(['const', [val]])) + return len(nodes) - 1 + +# there many hacky things here: value_to_array is trying to mimick +# the multiple dispatch of julia. Also that we have to ask which expression is which +# in order to get the constants correctly +# also, for sums, we are not considering coefficients, because basically all coefficients are 1 +# haven't even consider substractions, but I guess we would interpret them as a - b = a + (-1) * b +def expr_to_array(expr, nodes): + """adds expression to array""" + op = expr._op + if op == Operator.const: # FIXME: constant expr should also have children! + nodes.append(tuple([op, [expr.number]])) + elif op != Operator.varidx: + indices = [] + nchildren = len(expr.children) + for child in expr.children: + pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes' + indices.append(pos) + if op == Operator.power: + pos = value_to_array(expr.expo, nodes) + indices.append(pos) + elif (op == Operator.add and expr.constant != 0.0) or (op == Operator.prod and expr.constant != 1.0): + pos = value_to_array(expr.constant, nodes) + indices.append(pos) + nodes.append( tuple( [op, indices] ) ) + else: # var + nodes.append( tuple( [op, expr.children] ) ) + return len(nodes) - 1 diff --git a/src/pyscipopt/heuristic.pxi b/src/pyscipopt/heuristic.pxi new file mode 100644 index 0000000..9303156 --- /dev/null +++ b/src/pyscipopt/heuristic.pxi @@ -0,0 +1,79 @@ +##@file heuristic.pxi +#@brief Base class of the Heuristics Plugin +cdef class Heur: + cdef public Model model + cdef public str name + + def heurfree(self): + '''calls destructor and frees memory of primal heuristic''' + pass + + def heurinit(self): + '''initializes primal heuristic''' + pass + + def heurexit(self): + '''calls exit method of primal heuristic''' + pass + + def heurinitsol(self): + '''informs primal heuristic that the branch and bound process is being started''' + pass + + def heurexitsol(self): + '''informs primal heuristic that the branch and bound process data is being freed''' + pass + + def heurexec(self, heurtiming, nodeinfeasible): + '''should the heuristic the executed at the given depth, frequency, timing,...''' + print("python error in heurexec: this method needs to be implemented") + return {} + + + +cdef SCIP_RETCODE PyHeurCopy (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyHeurFree (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + cdef SCIP_HEURDATA* heurdata + heurdata = SCIPheurGetData(heur) + PyHeur = heurdata + PyHeur.heurfree() + Py_DECREF(PyHeur) + return SCIP_OKAY + +cdef SCIP_RETCODE PyHeurInit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + cdef SCIP_HEURDATA* heurdata + heurdata = SCIPheurGetData(heur) + PyHeur = heurdata + PyHeur.heurinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyHeurExit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + cdef SCIP_HEURDATA* heurdata + heurdata = SCIPheurGetData(heur) + PyHeur = heurdata + PyHeur.heurexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyHeurInitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + cdef SCIP_HEURDATA* heurdata + heurdata = SCIPheurGetData(heur) + PyHeur = heurdata + PyHeur.heurinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyHeurExitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + cdef SCIP_HEURDATA* heurdata + heurdata = SCIPheurGetData(heur) + PyHeur = heurdata + PyHeur.heurexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyHeurExec (SCIP* scip, SCIP_HEUR* heur, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_HEURDATA* heurdata + heurdata = SCIPheurGetData(heur) + PyHeur = heurdata + result_dict = PyHeur.heurexec(heurtiming, nodeinfeasible) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY diff --git a/src/pyscipopt/lp.pxi b/src/pyscipopt/lp.pxi new file mode 100644 index 0000000..04f6fde --- /dev/null +++ b/src/pyscipopt/lp.pxi @@ -0,0 +1,456 @@ +##@file lp.pxi +#@brief Base class of the LP Plugin +cdef class LP: + cdef SCIP_LPI* lpi + cdef readonly str name + + def __init__(self, name="LP", sense="minimize"): + """ + Keyword arguments: + name -- the name of the problem (default 'LP') + sense -- objective sense (default minimize) + """ + self.name = name + n = str_conversion(name) + if sense == "minimize": + PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MINIMIZE)) + elif sense == "maximize": + PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MAXIMIZE)) + else: + raise Warning("unrecognized objective sense") + + def __dealloc__(self): + PY_SCIP_CALL(SCIPlpiFree(&(self.lpi))) + + def __repr__(self): + return self.name + + def writeLP(self, filename): + """Writes LP to a file. + + Keyword arguments: + filename -- the name of the file to be used + """ + PY_SCIP_CALL(SCIPlpiWriteLP(self.lpi, filename)) + + def readLP(self, filename): + """Reads LP from a file. + + Keyword arguments: + filename -- the name of the file to be used + """ + PY_SCIP_CALL(SCIPlpiReadLP(self.lpi, filename)) + + def infinity(self): + """Returns infinity value of the LP. + """ + return SCIPlpiInfinity(self.lpi) + + def isInfinity(self, val): + """Checks if a given value is equal to the infinity value of the LP. + + Keyword arguments: + val -- value that should be checked + """ + return SCIPlpiIsInfinity(self.lpi, val) + + def addCol(self, entries, obj = 0.0, lb = 0.0, ub = None): + """Adds a single column to the LP. + + Keyword arguments: + entries -- list of tuples, each tuple consists of a row index and a coefficient + obj -- objective coefficient (default 0.0) + lb -- lower bound (default 0.0) + ub -- upper bound (default infinity) + """ + nnonz = len(entries) + + cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + cdef int* c_inds = malloc(nnonz * sizeof(int)) + cdef SCIP_Real c_obj + cdef SCIP_Real c_lb + cdef SCIP_Real c_ub + cdef int c_beg + + c_obj = obj + c_lb = lb + c_ub = ub if ub != None else self.infinity() + c_beg = 0 + + for i,entry in enumerate(entries): + c_inds[i] = entry[0] + c_coefs[i] = entry[1] + + PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, 1, &c_obj, &c_lb, &c_ub, NULL, nnonz, &c_beg, c_inds, c_coefs)) + + free(c_coefs) + free(c_inds) + + def addCols(self, entrieslist, objs = None, lbs = None, ubs = None): + """Adds multiple columns to the LP. + + Keyword arguments: + entrieslist -- list containing lists of tuples, each tuple contains a coefficient and a row index + objs -- objective coefficient (default 0.0) + lbs -- lower bounds (default 0.0) + ubs -- upper bounds (default infinity) + """ + + ncols = len(entrieslist) + nnonz = sum(len(entries) for entries in entrieslist) + + cdef SCIP_Real* c_objs = malloc(ncols * sizeof(SCIP_Real)) + cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) + cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) + cdef SCIP_Real* c_coefs + cdef int* c_inds + cdef int* c_beg + + + if nnonz > 0: + c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + c_inds = malloc(nnonz * sizeof(int)) + c_beg = malloc(ncols * sizeof(int)) + + tmp = 0 + for i,entries in enumerate(entrieslist): + c_objs[i] = objs[i] if objs != None else 0.0 + c_lbs[i] = lbs[i] if lbs != None else 0.0 + c_ubs[i] = ubs[i] if ubs != None else self.infinity() + c_beg[i] = tmp + + for entry in entries: + c_inds[tmp] = entry[0] + c_coefs[tmp] = entry[1] + tmp += 1 + + PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, ncols, c_objs, c_lbs, c_ubs, NULL, nnonz, c_beg, c_inds, c_coefs)) + + free(c_beg) + free(c_inds) + free(c_coefs) + else: + for i in range(len(entrieslist)): + c_objs[i] = objs[i] if objs != None else 0.0 + c_lbs[i] = lbs[i] if lbs != None else 0.0 + c_ubs[i] = ubs[i] if ubs != None else self.infinity() + + PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, ncols, c_objs, c_lbs, c_ubs, NULL, 0, NULL, NULL, NULL)) + + free(c_ubs) + free(c_lbs) + free(c_objs) + + def delCols(self, firstcol, lastcol): + """Deletes a range of columns from the LP. + + Keyword arguments: + firstcol -- first column to delete + lastcol -- last column to delete + """ + PY_SCIP_CALL(SCIPlpiDelCols(self.lpi, firstcol, lastcol)) + + def addRow(self, entries, lhs=0.0, rhs=None): + """Adds a single row to the LP. + + Keyword arguments: + entries -- list of tuples, each tuple contains a coefficient and a column index + lhs -- left-hand side of the row (default 0.0) + rhs -- right-hand side of the row (default infinity) + """ + beg = 0 + nnonz = len(entries) + + cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + cdef int* c_inds = malloc(nnonz * sizeof(int)) + cdef SCIP_Real c_lhs + cdef SCIP_Real c_rhs + cdef int c_beg + + c_lhs = lhs + c_rhs = rhs if rhs != None else self.infinity() + c_beg = 0 + + for i,entry in enumerate(entries): + c_inds[i] = entry[0] + c_coefs[i] = entry[1] + + PY_SCIP_CALL(SCIPlpiAddRows(self.lpi, 1, &c_lhs, &c_rhs, NULL, nnonz, &c_beg, c_inds, c_coefs)) + + free(c_coefs) + free(c_inds) + + def addRows(self, entrieslist, lhss = None, rhss = None): + """Adds multiple rows to the LP. + + Keyword arguments: + entrieslist -- list containing lists of tuples, each tuple contains a coefficient and a column index + lhss -- left-hand side of the row (default 0.0) + rhss -- right-hand side of the row (default infinity) + """ + nrows = len(entrieslist) + nnonz = sum(len(entries) for entries in entrieslist) + + cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) + cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + cdef int* c_inds = malloc(nnonz * sizeof(int)) + cdef int* c_beg = malloc(nrows * sizeof(int)) + + tmp = 0 + for i,entries in enumerate(entrieslist): + c_lhss[i] = lhss[i] if lhss != None else 0.0 + c_rhss[i] = rhss[i] if rhss != None else self.infinity() + c_beg[i] = tmp + + for entry in entries: + c_inds[tmp] = entry[0] + c_coefs[tmp] = entry[1] + tmp += 1 + + PY_SCIP_CALL(SCIPlpiAddRows(self.lpi, nrows, c_lhss, c_rhss, NULL, nnonz, c_beg, c_inds, c_coefs)) + + free(c_beg) + free(c_inds) + free(c_coefs) + free(c_lhss) + free(c_rhss) + + def delRows(self, firstrow, lastrow): + """Deletes a range of rows from the LP. + + Keyword arguments: + firstrow -- first row to delete + lastrow -- last row to delete + """ + PY_SCIP_CALL(SCIPlpiDelRows(self.lpi, firstrow, lastrow)) + + def getBounds(self, firstcol = 0, lastcol = None): + """Returns all lower and upper bounds for a range of columns. + + Keyword arguments: + firstcol -- first column (default 0) + lastcol -- last column (default ncols - 1) + """ + lastcol = lastcol if lastcol != None else self.ncols() - 1 + + if firstcol > lastcol: + return None + + ncols = lastcol - firstcol + 1 + cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) + cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) + PY_SCIP_CALL(SCIPlpiGetBounds(self.lpi, firstcol, lastcol, c_lbs, c_ubs)) + + lbs = [] + ubs = [] + + for i in range(ncols): + lbs.append(c_lbs[i]) + ubs.append(c_ubs[i]) + + free(c_ubs) + free(c_lbs) + + return lbs, ubs + + def getSides(self, firstrow = 0, lastrow = None): + """Returns all left- and right-hand sides for a range of rows. + + Keyword arguments: + firstrow -- first row (default 0) + lastrow -- last row (default nrows - 1) + """ + lastrow = lastrow if lastrow != None else self.nrows() - 1 + + if firstrow > lastrow: + return None + + nrows = lastrow - firstrow + 1 + cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) + PY_SCIP_CALL(SCIPlpiGetSides(self.lpi, firstrow, lastrow, c_lhss, c_rhss)) + + lhss = [] + rhss = [] + + for i in range(firstrow, lastrow + 1): + lhss.append(c_lhss[i]) + rhss.append(c_rhss[i]) + + free(c_rhss) + free(c_lhss) + + return lhss, rhss + + def chgObj(self, col, obj): + """Changes objective coefficient of a single column. + + Keyword arguments: + col -- column to change + obj -- new objective coefficient + """ + cdef int c_col = col + cdef SCIP_Real c_obj = obj + PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj)) + + def chgCoef(self, row, col, newval): + """Changes a single coefficient in the LP. + + Keyword arguments: + row -- row to change + col -- column to change + newval -- new coefficient + """ + PY_SCIP_CALL(SCIPlpiChgCoef(self.lpi, row, col, newval)) + + def chgBound(self, col, lb, ub): + """Changes the lower and upper bound of a single column. + + Keyword arguments: + col -- column to change + lb -- new lower bound + ub -- new upper bound + """ + cdef int c_col = col + cdef SCIP_Real c_lb = lb + cdef SCIP_Real c_ub = ub + PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub)) + + def chgSide(self, row, lhs, rhs): + """Changes the left- and right-hand side of a single row. + + Keyword arguments: + row -- row to change + lhs -- new left-hand side + rhs -- new right-hand side + """ + cdef int c_row = row + cdef SCIP_Real c_lhs = lhs + cdef SCIP_Real c_rhs = rhs + PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs)) + + def clear(self): + """Clears the whole LP.""" + PY_SCIP_CALL(SCIPlpiClear(self.lpi)) + + def nrows(self): + """Returns the number of rows.""" + cdef int nrows + PY_SCIP_CALL(SCIPlpiGetNRows(self.lpi, &nrows)) + return nrows + + def ncols(self): + """Returns the number of columns.""" + cdef int ncols + PY_SCIP_CALL(SCIPlpiGetNCols(self.lpi, &ncols)) + return ncols + + def solve(self, dual=True): + """Solves the current LP. + + Keyword arguments: + dual -- use the dual or primal Simplex method (default: dual) + """ + if dual: + PY_SCIP_CALL(SCIPlpiSolveDual(self.lpi)) + else: + PY_SCIP_CALL(SCIPlpiSolvePrimal(self.lpi)) + + cdef SCIP_Real objval + PY_SCIP_CALL(SCIPlpiGetObjval(self.lpi, &objval)) + return objval + + def getPrimal(self): + """Returns the primal solution of the last LP solve.""" + ncols = self.ncols() + cdef SCIP_Real* c_primalsol = malloc(ncols * sizeof(SCIP_Real)) + PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, c_primalsol, NULL, NULL, NULL)) + primalsol = [0.0] * ncols + for i in range(ncols): + primalsol[i] = c_primalsol[i] + free(c_primalsol) + + return primalsol + + def isPrimalFeasible(self): + """Returns True iff LP is proven to be primal feasible.""" + return SCIPlpiIsPrimalFeasible(self.lpi) + + def getDual(self): + """Returns the dual solution of the last LP solve.""" + nrows = self.nrows() + cdef SCIP_Real* c_dualsol = malloc(nrows * sizeof(SCIP_Real)) + PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, c_dualsol, NULL, NULL)) + dualsol = [0.0] * nrows + for i in range(nrows): + dualsol[i] = c_dualsol[i] + free(c_dualsol) + + return dualsol + + def isDualFeasible(self): + """Returns True iff LP is proven to be dual feasible.""" + return SCIPlpiIsDualFeasible(self.lpi) + + def getPrimalRay(self): + """Returns a primal ray if possible, None otherwise.""" + if not SCIPlpiHasPrimalRay(self.lpi): + return None + ncols = self.ncols() + cdef SCIP_Real* c_ray = malloc(ncols * sizeof(SCIP_Real)) + PY_SCIP_CALL(SCIPlpiGetPrimalRay(self.lpi, c_ray)) + ray = [0.0] * ncols + for i in range(ncols): + ray[i] = c_ray[i] + free(c_ray) + + return ray + + def getDualRay(self): + """Returns a dual ray if possible, None otherwise.""" + if not SCIPlpiHasDualRay(self.lpi): + return None + nrows = self.nrows() + cdef SCIP_Real* c_ray = malloc(nrows * sizeof(SCIP_Real)) + PY_SCIP_CALL(SCIPlpiGetDualfarkas(self.lpi, c_ray)) + ray = [0.0] * nrows + for i in range(nrows): + ray[i] = c_ray[i] + free(c_ray) + + return ray + + def getNIterations(self): + """Returns the number of LP iterations of the last LP solve.""" + cdef int niters + PY_SCIP_CALL(SCIPlpiGetIterations(self.lpi, &niters)) + return niters + + def getRedcost(self): + """Returns the reduced cost vector of the last LP solve.""" + ncols = self.ncols() + + cdef SCIP_Real* c_redcost = malloc(ncols * sizeof(SCIP_Real)) + PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, NULL, NULL, c_redcost)) + + redcost = [] + for i in range(ncols): + redcost[i].append(c_redcost[i]) + + free(c_redcost) + return redcost + + def getBasisInds(self): + """Returns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + nrows = self.nrows() + cdef int* c_binds = malloc(nrows * sizeof(int)) + + PY_SCIP_CALL(SCIPlpiGetBasisInd(self.lpi, c_binds)) + + binds = [] + for i in range(nrows): + binds.append(c_binds[i]) + + free(c_binds) + return binds diff --git a/src/pyscipopt/nodesel.pxi b/src/pyscipopt/nodesel.pxi new file mode 100644 index 0000000..a3e832f --- /dev/null +++ b/src/pyscipopt/nodesel.pxi @@ -0,0 +1,101 @@ +##@file nodesel.pxi +#@brief Base class of the Nodesel Plugin +cdef class Nodesel: + cdef public Model model + + def nodefree(self): + '''frees memory of node selector''' + pass + + def nodeinit(self): + ''' executed after the problem is transformed. use this call to initialize node selector data.''' + pass + + def nodeexit(self): + '''executed before the transformed problem is freed''' + pass + + def nodeinitsol(self): + '''executed when the presolving is finished and the branch-and-bound process is about to begin''' + pass + + def nodeexitsol(self): + '''executed before the branch-and-bound process is freed''' + pass + + def nodeselect(self): + '''first method called in each iteration in the main solving loop. ''' + # this method needs to be implemented by the user + return {} + + def nodecomp(self, node1, node2): + ''' + compare two leaves of the current branching tree + + It should return the following values: + + value < 0, if node 1 comes before (is better than) node 2 + value = 0, if both nodes are equally good + value > 0, if node 1 comes after (is worse than) node 2. + ''' + # this method needs to be implemented by the user + return 0 + + +cdef SCIP_RETCODE PyNodeselCopy (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyNodeselFree (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + cdef SCIP_NODESELDATA* nodeseldata + nodeseldata = SCIPnodeselGetData(nodesel) + PyNodesel = nodeseldata + PyNodesel.nodefree() + Py_DECREF(PyNodesel) + return SCIP_OKAY + +cdef SCIP_RETCODE PyNodeselInit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + cdef SCIP_NODESELDATA* nodeseldata + nodeseldata = SCIPnodeselGetData(nodesel) + PyNodesel = nodeseldata + PyNodesel.nodeinit() + return SCIP_OKAY + + +cdef SCIP_RETCODE PyNodeselExit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + cdef SCIP_NODESELDATA* nodeseldata + nodeseldata = SCIPnodeselGetData(nodesel) + PyNodesel = nodeseldata + PyNodesel.nodeexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyNodeselInitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + cdef SCIP_NODESELDATA* nodeseldata + nodeseldata = SCIPnodeselGetData(nodesel) + PyNodesel = nodeseldata + PyNodesel.nodeinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyNodeselExitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + cdef SCIP_NODESELDATA* nodeseldata + nodeseldata = SCIPnodeselGetData(nodesel) + PyNodesel = nodeseldata + PyNodesel.nodeexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyNodeselSelect (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE** selnode) noexcept with gil: + cdef SCIP_NODESELDATA* nodeseldata + nodeseldata = SCIPnodeselGetData(nodesel) + PyNodesel = nodeseldata + result_dict = PyNodesel.nodeselect() + selected_node = (result_dict.get("selnode", None)) + selnode[0] = selected_node.scip_node + return SCIP_OKAY + +cdef int PyNodeselComp (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE* node1, SCIP_NODE* node2) noexcept with gil: + cdef SCIP_NODESELDATA* nodeseldata + nodeseldata = SCIPnodeselGetData(nodesel) + PyNodesel = nodeseldata + n1 = Node.create(node1) + n2 = Node.create(node2) + result = PyNodesel.nodecomp(n1, n2) # + return result diff --git a/src/pyscipopt/presol.pxi b/src/pyscipopt/presol.pxi new file mode 100644 index 0000000..13bd9a6 --- /dev/null +++ b/src/pyscipopt/presol.pxi @@ -0,0 +1,93 @@ +##@file presol.pxi +#@brief Base class of the Presolver Plugin +cdef class Presol: + cdef public Model model + + def presolfree(self): + '''frees memory of presolver''' + pass + + def presolinit(self): + '''initializes presolver''' + pass + + def presolexit(self): + '''deinitializes presolver''' + pass + + def presolinitpre(self): + '''informs presolver that the presolving process is being started''' + pass + + def presolexitpre(self): + '''informs presolver that the presolving process is finished''' + pass + + def presolexec(self, nrounds, presoltiming): + '''executes presolver''' + print("python error in presolexec: this method needs to be implemented") + return {} + + + +cdef SCIP_RETCODE PyPresolCopy (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyPresolFree (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + cdef SCIP_PRESOLDATA* presoldata + presoldata = SCIPpresolGetData(presol) + PyPresol = presoldata + PyPresol.presolfree() + Py_DECREF(PyPresol) + return SCIP_OKAY + +cdef SCIP_RETCODE PyPresolInit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + cdef SCIP_PRESOLDATA* presoldata + presoldata = SCIPpresolGetData(presol) + PyPresol = presoldata + PyPresol.presolinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPresolExit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + cdef SCIP_PRESOLDATA* presoldata + presoldata = SCIPpresolGetData(presol) + PyPresol = presoldata + PyPresol.presolexit() + return SCIP_OKAY + + +cdef SCIP_RETCODE PyPresolInitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + cdef SCIP_PRESOLDATA* presoldata + presoldata = SCIPpresolGetData(presol) + PyPresol = presoldata + PyPresol.presolinitpre() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPresolExitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + cdef SCIP_PRESOLDATA* presoldata + presoldata = SCIPpresolGetData(presol) + PyPresol = presoldata + PyPresol.presolexitpre() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPresolExec (SCIP* scip, SCIP_PRESOL* presol, int nrounds, SCIP_PRESOLTIMING presoltiming, + int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes, + int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_PRESOLDATA* presoldata + presoldata = SCIPpresolGetData(presol) + PyPresol = presoldata + result_dict = PyPresol.presolexec(nrounds, presoltiming) + result[0] = result_dict.get("result", result[0]) + nfixedvars[0] += result_dict.get("nnewfixedvars", 0) + naggrvars[0] += result_dict.get("nnewaggrvars", 0) + nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + nchgbds[0] += result_dict.get("nnewchgbds", 0) + naddholes[0] += result_dict.get("nnewaddholes", 0) + ndelconss[0] += result_dict.get("nnewdelconss", 0) + naddconss[0] += result_dict.get("nnewaddconss", 0) + nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) + nchgsides[0] += result_dict.get("nnewchgsides", 0) + return SCIP_OKAY diff --git a/src/pyscipopt/pricer.pxi b/src/pyscipopt/pricer.pxi new file mode 100644 index 0000000..a218b25 --- /dev/null +++ b/src/pyscipopt/pricer.pxi @@ -0,0 +1,90 @@ +##@file pricer.pxi +#@brief Base class of the Pricers Plugin +cdef class Pricer: + cdef public Model model + + def pricerfree(self): + '''calls destructor and frees memory of variable pricer ''' + pass + + def pricerinit(self): + '''initializes variable pricer''' + pass + + def pricerexit(self): + '''calls exit method of variable pricer''' + pass + + def pricerinitsol(self): + '''informs variable pricer that the branch and bound process is being started ''' + pass + + def pricerexitsol(self): + '''informs variable pricer that the branch and bound process data is being freed''' + pass + + def pricerredcost(self): + '''calls reduced cost pricing method of variable pricer''' + raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") + + def pricerfarkas(self): + '''calls Farkas pricing method of variable pricer''' + raise NotImplementedError("pricerfarkas() is a fundamental callback and should be implemented in the derived class") + + + +cdef SCIP_RETCODE PyPricerCopy (SCIP* scip, SCIP_PRICER* pricer, SCIP_Bool* valid) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyPricerFree (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + cdef SCIP_PRICERDATA* pricerdata + pricerdata = SCIPpricerGetData(pricer) + PyPricer = pricerdata + PyPricer.pricerfree() + Py_DECREF(PyPricer) + return SCIP_OKAY + +cdef SCIP_RETCODE PyPricerInit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + cdef SCIP_PRICERDATA* pricerdata + pricerdata = SCIPpricerGetData(pricer) + PyPricer = pricerdata + PyPricer.pricerinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPricerExit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + cdef SCIP_PRICERDATA* pricerdata + pricerdata = SCIPpricerGetData(pricer) + PyPricer = pricerdata + PyPricer.pricerexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPricerInitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + cdef SCIP_PRICERDATA* pricerdata + pricerdata = SCIPpricerGetData(pricer) + PyPricer = pricerdata + PyPricer.pricerinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPricerExitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + cdef SCIP_PRICERDATA* pricerdata + pricerdata = SCIPpricerGetData(pricer) + PyPricer = pricerdata + PyPricer.pricerexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPricerRedcost (SCIP* scip, SCIP_PRICER* pricer, SCIP_Real* lowerbound, SCIP_Bool* stopearly, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_PRICERDATA* pricerdata + pricerdata = SCIPpricerGetData(pricer) + PyPricer = pricerdata + result_dict = PyPricer.pricerredcost() + result[0] = result_dict.get("result", result[0]) + lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + stopearly[0] = result_dict.get("stopearly", stopearly[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyPricerFarkas (SCIP* scip, SCIP_PRICER* pricer, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_PRICERDATA* pricerdata + pricerdata = SCIPpricerGetData(pricer) + PyPricer = pricerdata + result[0] = PyPricer.pricerfarkas().get("result", result[0]) + return SCIP_OKAY diff --git a/src/pyscipopt/propagator.pxi b/src/pyscipopt/propagator.pxi new file mode 100644 index 0000000..4508efe --- /dev/null +++ b/src/pyscipopt/propagator.pxi @@ -0,0 +1,163 @@ +##@file propagator.pxi +#@brief Base class of the Propagators Plugin +cdef class Prop: + cdef public Model model + + def propfree(self): + '''calls destructor and frees memory of propagator''' + pass + + def propinit(self): + '''initializes propagator''' + pass + + def propexit(self): + '''calls exit method of propagator''' + pass + + def propinitsol(self): + '''informs propagator that the prop and bound process is being started''' + pass + + def propexitsol(self, restart): + '''informs propagator that the prop and bound process data is being freed''' + pass + + def propinitpre(self): + '''informs propagator that the presolving process is being started''' + pass + + def propexitpre(self): + '''informs propagator that the presolving process is finished''' + pass + + def proppresol(self, nrounds, presoltiming, result_dict): + '''executes presolving method of propagator''' + pass + + def propexec(self, proptiming): + '''calls execution method of propagator''' + print("python error in propexec: this method needs to be implemented") + return {} + + def propresprop(self, confvar, inferinfo, bdtype, relaxedbd): + '''resolves the given conflicting bound, that was reduced by the given propagator''' + print("python error in propresprop: this method needs to be implemented") + return {} + + + +cdef SCIP_RETCODE PyPropCopy (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropFree (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + PyProp.propfree() + Py_DECREF(PyProp) + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropInit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + PyProp.propinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropExit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + PyProp.propexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropInitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + PyProp.propinitpre() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropExitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + PyProp.propexitpre() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropInitsol (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + PyProp.propinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropExitsol (SCIP* scip, SCIP_PROP* prop, SCIP_Bool restart) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + PyProp.propexitsol(restart) + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropPresol (SCIP* scip, SCIP_PROP* prop, int nrounds, SCIP_PRESOLTIMING presoltiming, + int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes, + int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + # dictionary for input/output parameters + result_dict = {} + result_dict["nfixedvars"] = nfixedvars[0] + result_dict["naggrvars"] = naggrvars[0] + result_dict["nchgvartypes"] = nchgvartypes[0] + result_dict["nchgbds"] = nchgbds[0] + result_dict["naddholes"] = naddholes[0] + result_dict["ndelconss"] = ndelconss[0] + result_dict["naddconss"] = naddconss[0] + result_dict["nupgdconss"] = nupgdconss[0] + result_dict["nchgcoefs"] = nchgcoefs[0] + result_dict["nchgsides"] = nchgsides[0] + result_dict["result"] = result[0] + PyProp.proppresol(nrounds, presoltiming, + nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + result[0] = result_dict["result"] + nfixedvars[0] = result_dict["nfixedvars"] + naggrvars[0] = result_dict["naggrvars"] + nchgvartypes[0] = result_dict["nchgvartypes"] + nchgbds[0] = result_dict["nchgbds"] + naddholes[0] = result_dict["naddholes"] + ndelconss[0] = result_dict["ndelconss"] + naddconss[0] = result_dict["naddconss"] + nupgdconss[0] = result_dict["nupgdconss"] + nchgcoefs[0] = result_dict["nchgcoefs"] + nchgsides[0] = result_dict["nchgsides"] + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropExec (SCIP* scip, SCIP_PROP* prop, SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_PROPDATA* propdata + propdata = SCIPpropGetData(prop) + PyProp = propdata + returnvalues = PyProp.propexec(proptiming) + result_dict = returnvalues + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyPropResProp (SCIP* scip, SCIP_PROP* prop, SCIP_VAR* infervar, int inferinfo, + SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_PROPDATA* propdata + cdef SCIP_VAR* tmp + tmp = infervar + propdata = SCIPpropGetData(prop) + confvar = Variable.create(tmp) + + #TODO: parse bdchgidx? + + PyProp = propdata + returnvalues = PyProp.propresprop(confvar, inferinfo, boundtype, relaxedbd) + result_dict = returnvalues + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY diff --git a/src/pyscipopt/reader.pxi b/src/pyscipopt/reader.pxi new file mode 100644 index 0000000..2c45585 --- /dev/null +++ b/src/pyscipopt/reader.pxi @@ -0,0 +1,64 @@ +##@file reader.pxi +#@brief Base class of the Reader Plugin +cdef class Reader: + cdef public Model model + cdef public str name + + def readerfree(self): + '''calls destructor and frees memory of reader''' + pass + + def readerread(self, filename): + '''calls read method of reader''' + return {} + + def readerwrite(self, file, name, transformed, objsense, objscale, objoffset, binvars, intvars, + implvars, contvars, fixedvars, startnvars, conss, maxnconss, startnconss, genericnames): + '''calls write method of reader''' + return {} + + +cdef SCIP_RETCODE PyReaderCopy (SCIP* scip, SCIP_READER* reader) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyReaderFree (SCIP* scip, SCIP_READER* reader) noexcept with gil: + cdef SCIP_READERDATA* readerdata + readerdata = SCIPreaderGetData(reader) + PyReader = readerdata + PyReader.readerfree() + Py_DECREF(PyReader) + return SCIP_OKAY + +cdef SCIP_RETCODE PyReaderRead (SCIP* scip, SCIP_READER* reader, const char* filename, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_READERDATA* readerdata + readerdata = SCIPreaderGetData(reader) + PyReader = readerdata + PyFilename = filename.decode('utf-8') + result_dict = PyReader.readerread(PyFilename) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY + +cdef SCIP_RETCODE PyReaderWrite (SCIP* scip, SCIP_READER* reader, FILE* file, + const char* name, SCIP_PROBDATA* probdata, SCIP_Bool transformed, + SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, + SCIP_VAR** vars, int nvars, int nbinvars, int nintvars, int nimplvars, int ncontvars, + SCIP_VAR** fixedvars, int nfixedvars, int startnvars, + SCIP_CONS** conss, int nconss, int maxnconss, int startnconss, + SCIP_Bool genericnames, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_READERDATA* readerdata + readerdata = SCIPreaderGetData(reader) + cdef int fd = fileno(file) + PyFile = os.fdopen(fd, "w", closefd=False) + PyName = name.decode('utf-8') + PyBinVars = [Variable.create(vars[i]) for i in range(nbinvars)] + PyIntVars = [Variable.create(vars[i]) for i in range(nbinvars, nintvars)] + PyImplVars = [Variable.create(vars[i]) for i in range(nintvars, nimplvars)] + PyContVars = [Variable.create(vars[i]) for i in range(nimplvars, ncontvars)] + PyFixedVars = [Variable.create(fixedvars[i]) for i in range(nfixedvars)] + PyConss = [Constraint.create(conss[i]) for i in range(nconss)] + PyReader = readerdata + result_dict = PyReader.readerwrite(PyFile, PyName, transformed, objsense, objscale, objoffset, + PyBinVars, PyIntVars, PyImplVars, PyContVars, PyFixedVars, startnvars, + PyConss, maxnconss, startnconss, genericnames) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY diff --git a/src/pyscipopt/recipes/README.md b/src/pyscipopt/recipes/README.md new file mode 100644 index 0000000..91184b1 --- /dev/null +++ b/src/pyscipopt/recipes/README.md @@ -0,0 +1,6 @@ +# Recipes sub-package + +This sub-package provides a set of functions for common usecases for pyscipopt. This sub-package is for all functions +that don't necessarily reflect the core functionality of SCIP, but are useful for working with the solver. The functions +implemented in this sub-package might not be the most efficient way to solve/formulate a problem but would provide a +good starting point. diff --git a/src/pyscipopt/recipes/__init__.py b/src/pyscipopt/recipes/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/pyscipopt/recipes/infeasibilities.py b/src/pyscipopt/recipes/infeasibilities.py new file mode 100644 index 0000000..fde7086 --- /dev/null +++ b/src/pyscipopt/recipes/infeasibilities.py @@ -0,0 +1,50 @@ +from pyscipopt import Model, quicksum + + +def get_infeasible_constraints(orig_model: Model, verbose=False): + """ + Given a model, adds slack variables to all the constraints and minimizes a binary variable that indicates if they're positive. + Positive slack variables correspond to infeasible constraints. + """ + + model = Model(sourceModel=orig_model, origcopy=True) # to preserve the model + + slack = {} + aux = {} + binary = {} + aux_binary = {} + + for c in model.getConss(): + + slack[c.name] = model.addVar(lb=-float("inf"), name="s_"+c.name) + model.addConsCoeff(c, slack[c.name], 1) + binary[c.name] = model.addVar(vtype="B") # Binary variable to get minimum infeasible constraints. See PR #857. + + # getting the absolute value because of <= and >= constraints + aux[c.name] = model.addVar() + model.addCons(aux[c.name] >= slack[c.name]) + model.addCons(aux[c.name] >= -slack[c.name]) + + # modeling aux > 0 => binary = 1 constraint. See https://or.stackexchange.com/q/12142/5352 for an explanation + aux_binary[c.name] = model.addVar(vtype="B") + model.addCons(binary[c.name]+aux_binary[c.name] == 1) + model.addConsSOS1([aux[c.name], aux_binary[c.name]]) + + model.setObjective(quicksum(binary[c.name] for c in orig_model.getConss())) + model.hideOutput() + model.optimize() + + n_infeasibilities_detected = 0 + for c in binary: + if model.isGT(model.getVal(binary[c]), 0): + n_infeasibilities_detected += 1 + print("Constraint %s is causing an infeasibility." % c) + + if verbose: + if n_infeasibilities_detected > 0: + print("If the constraint names are unhelpful, consider giving them\ + a suitable name when creating the model with model.addCons(..., name=\"the_name_you_want\")") + else: + print("Model is feasible.") + + return n_infeasibilities_detected, aux \ No newline at end of file diff --git a/src/pyscipopt/recipes/nonlinear.py b/src/pyscipopt/recipes/nonlinear.py new file mode 100644 index 0000000..d4f4857 --- /dev/null +++ b/src/pyscipopt/recipes/nonlinear.py @@ -0,0 +1,18 @@ +from pyscipopt import Model + + +def set_nonlinear_objective(model: Model, expr, sense="minimize"): + """ + Takes a nonlinear expression and performs an epigraph reformulation. + """ + + assert expr.degree() > 1, "For linear objectives, please use the setObjective method." + new_obj = model.addVar(lb=-float("inf"), obj=1) + if sense == "minimize": + model.addCons(expr <= new_obj) + model.setMinimize() + elif sense == "maximize": + model.addCons(expr >= new_obj) + model.setMaximize() + else: + raise Warning("unrecognized optimization sense: %s" % sense) diff --git a/src/pyscipopt/recipes/piecewise.py b/src/pyscipopt/recipes/piecewise.py new file mode 100644 index 0000000..05029a5 --- /dev/null +++ b/src/pyscipopt/recipes/piecewise.py @@ -0,0 +1,39 @@ +from typing import List + +from pyscipopt import Model, quicksum, Variable, Constraint + + +def add_piecewise_linear_cons(model: Model, X: Variable, Y: Variable, a: List[float], b: List[float]) -> Constraint: + """add constraint of the form y = f(x), where f is a piecewise linear function + + :param model: pyscipopt model to add the constraint to + :param X: x variable + :param Y: y variable + :param a: array with x-coordinates of the points in the piecewise linear relation + :param b: array with y-coordinate of the points in the piecewise linear relation + + Disclaimer: For the moment, can only model 2d piecewise linear functions + Adapted from https://github.com/scipopt/PySCIPOpt/blob/master/examples/finished/piecewise.py + """ + assert len(a) == len(b), "Must have the same number of x and y-coordinates" + + K = len(a) - 1 + w, z = {}, {} + for k in range(K): + w[k] = model.addVar(lb=-model.infinity()) + z[k] = model.addVar(vtype="B") + + for k in range(K): + model.addCons(w[k] >= a[k] * z[k]) + model.addCons(w[k] <= a[k + 1] * z[k]) + + model.addCons(quicksum(z[k] for k in range(K)) == 1) + + model.addCons(X == quicksum(w[k] for k in range(K))) + + c = [float(b[k + 1] - b[k]) / (a[k + 1] - a[k]) for k in range(K)] + d = [b[k] - c[k] * a[k] for k in range(K)] + + new_cons = model.addCons(Y == quicksum(d[k] * z[k] + c[k] * w[k] for k in range(K))) + + return new_cons diff --git a/src/pyscipopt/relax.pxi b/src/pyscipopt/relax.pxi new file mode 100644 index 0000000..81695e8 --- /dev/null +++ b/src/pyscipopt/relax.pxi @@ -0,0 +1,80 @@ +##@file relax.pxi +#@brief Base class of the Relaxator Plugin +cdef class Relax: + cdef public Model model + cdef public str name + + def relaxfree(self): + '''calls destructor and frees memory of relaxation handler''' + pass + + def relaxinit(self): + '''initializes relaxation handler''' + pass + + def relaxexit(self): + '''calls exit method of relaxation handler''' + pass + + def relaxinitsol(self): + '''informs relaxaton handler that the branch and bound process is being started''' + pass + + def relaxexitsol(self): + '''informs relaxation handler that the branch and bound process data is being freed''' + pass + + def relaxexec(self): + '''callls execution method of relaxation handler''' + print("python error in relaxexec: this method needs to be implemented") + return{} + + +cdef SCIP_RETCODE PyRelaxCopy (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + return SCIP_OKAY + +cdef SCIP_RETCODE PyRelaxFree (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + cdef SCIP_RELAXDATA* relaxdata + relaxdata = SCIPrelaxGetData(relax) + PyRelax = relaxdata + PyRelax.relaxfree() + Py_DECREF(PyRelax) + return SCIP_OKAY + +cdef SCIP_RETCODE PyRelaxInit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + cdef SCIP_RELAXDATA* relaxdata + relaxdata = SCIPrelaxGetData(relax) + PyRelax = relaxdata + PyRelax.relaxinit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyRelaxExit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + cdef SCIP_RELAXDATA* relaxdata + relaxdata = SCIPrelaxGetData(relax) + PyRelax = relaxdata + PyRelax.relaxexit() + return SCIP_OKAY + +cdef SCIP_RETCODE PyRelaxInitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + cdef SCIP_RELAXDATA* relaxdata + relaxdata = SCIPrelaxGetData(relax) + PyRelax = relaxdata + PyRelax.relaxinitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyRelaxExitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + cdef SCIP_RELAXDATA* relaxdata + relaxdata = SCIPrelaxGetData(relax) + PyRelax = relaxdata + PyRelax.relaxexitsol() + return SCIP_OKAY + +cdef SCIP_RETCODE PyRelaxExec (SCIP* scip, SCIP_RELAX* relax, SCIP_Real* lowerbound, SCIP_RESULT* result) noexcept with gil: + cdef SCIP_RELAXDATA* relaxdata + relaxdata = SCIPrelaxGetData(relax) + PyRelax = relaxdata + result_dict = PyRelax.relaxexec() + assert isinstance(result_dict, dict), "relaxexec() must return a dictionary." + lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + result[0] = result_dict.get("result", result[0]) + return SCIP_OKAY \ No newline at end of file diff --git a/src/pyscipopt/scip.c b/src/pyscipopt/scip.c new file mode 100644 index 0000000..60921fb --- /dev/null +++ b/src/pyscipopt/scip.c @@ -0,0 +1,270321 @@ +/* Generated by Cython 3.0.10 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [ + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/blockmemshell/memory.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/lpi/type_lpi.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/bendersdefcuts.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_and.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_cardinality.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_countsols.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_disjunction.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_indicator.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_linear.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_nonlinear.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_or.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_sos1.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_sos2.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/cons_xor.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_abs.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_exp.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_log.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_pow.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_product.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_sum.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_trig.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_value.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_var.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/expr_varidx.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/paramset.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/pub_expr.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/pub_lp.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/pub_nlp.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/scip.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/scip_cons.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/scip_expr.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/scip_nlp.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/scip_tree.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/scip_var.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/scipdefplugins.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/tree.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_benders.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_event.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_expr.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_history.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_lp.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_paramset.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_prob.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_result.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_retcode.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_set.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_stat.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_timing.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_tree.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/scip/type_var.h", + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include/tpi/tpi.h" + ], + "extra_compile_args": [ + "-std=c++11" + ], + "extra_link_args": [ + "-Wl,-rpath,/home/lentz/Schreibtisch/pygcgopt-venv/scip/lib" + ], + "include_dirs": [ + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/include" + ], + "libraries": [ + "scip" + ], + "library_dirs": [ + "/home/lentz/Schreibtisch/pygcgopt-venv/scip/lib" + ], + "name": "pyscipopt.scip", + "sources": [ + "src/pyscipopt/scip.pyx" + ] + }, + "module_name": "pyscipopt.scip" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + +#include "Python.h" + + #if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyFloat_FromString(obj) PyFloat_FromString(obj) + #else + #define __Pyx_PyFloat_FromString(obj) PyFloat_FromString(obj, NULL) + #endif + + + #if PY_MAJOR_VERSION <= 2 + #define PyDict_GetItemWithError _PyDict_GetItemWithError + #endif + + + #if (PY_VERSION_HEX < 0x030700b1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030600)) && !defined(PyContextVar_Get) + #define PyContextVar_Get(var, d, v) ((d) ? ((void)(var), Py_INCREF(d), (v)[0] = (d), 0) : ((v)[0] = NULL, 0) ) + #endif + +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. +#else +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" +#else +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_10" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x03000AF0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #define HAVE_LONG_LONG +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #endif +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) + #endif + #if PY_VERSION_HEX < 0x030700A3 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; + #else + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; + #else + typedef unsigned __int32 __pyx_uintptr_t; + #endif + #endif +#else + #include + typedef uintptr_t __pyx_uintptr_t; +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) + +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_DefaultClassType PyClass_Type + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#else + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif +#endif +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) +#else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__pyscipopt__scip +#define __PYX_HAVE_API__pyscipopt__scip +/* Early includes */ +#include "scip/type_retcode.h" +#include "scip/type_var.h" +#include "scip/type_prob.h" +#include "lpi/type_lpi.h" +#include "scip/type_lp.h" +#include "scip/type_result.h" +#include "scip/type_stat.h" +#include "scip/type_set.h" +#include "scip/type_tree.h" +#include "scip/type_paramset.h" +#include "scip/type_timing.h" +#include "scip/type_expr.h" +#include "scip/type_event.h" +#include "scip/type_benders.h" +#include "scip/type_history.h" +#include "scip/scip.h" +#include "scip/tree.h" +#include "scip/scipdefplugins.h" +#include "scip/bendersdefcuts.h" +#include "scip/cons_linear.h" +#include "scip/cons_nonlinear.h" +#include "scip/cons_sos1.h" +#include "scip/cons_sos2.h" +#include "scip/cons_disjunction.h" +#include "scip/cons_and.h" +#include "scip/cons_or.h" +#include "scip/cons_xor.h" +#include "scip/scip_cons.h" +#include "blockmemshell/memory.h" +#include "scip/scip_expr.h" +#include "scip/pub_expr.h" +#include "scip/expr_var.h" +#include "scip/expr_varidx.h" +#include "scip/expr_value.h" +#include "scip/expr_sum.h" +#include "scip/expr_abs.h" +#include "scip/expr_exp.h" +#include "scip/expr_log.h" +#include "scip/expr_trig.h" +#include "scip/expr_product.h" +#include "scip/expr_pow.h" +#include "scip/pub_nlp.h" +#include "scip/scip_nlp.h" +#include "scip/cons_cardinality.h" +#include "scip/cons_indicator.h" +#include "scip/cons_countsols.h" +#include "scip/paramset.h" +#include "scip/pub_lp.h" +#include "scip/scip_tree.h" +#include "scip/scip_var.h" +#include "tpi/tpi.h" +#include +#include +#include +#include "pythread.h" +#include +#include +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = (char) c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#include +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +#if !CYTHON_USE_MODULE_STATE +static PyObject *__pyx_m = NULL; +#endif +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm = __FILE__; +static const char *__pyx_filename; + +/* #### Code section: filename_table ### */ + +static const char *__pyx_f[] = { + "src/pyscipopt/scip.pxi", + "src/pyscipopt/expr.pxi", + "src/pyscipopt/lp.pxi", + "src/pyscipopt/benders.pxi", + "contextvars.pxd", + "src/pyscipopt/scip.pyx", + "", + "src/pyscipopt/benderscut.pxi", + "src/pyscipopt/branchrule.pxi", + "src/pyscipopt/conshdlr.pxi", + "src/pyscipopt/cutsel.pxi", + "src/pyscipopt/event.pxi", + "src/pyscipopt/heuristic.pxi", + "src/pyscipopt/presol.pxi", + "src/pyscipopt/pricer.pxi", + "src/pyscipopt/propagator.pxi", + "src/pyscipopt/sepa.pxi", + "src/pyscipopt/reader.pxi", + "src/pyscipopt/relax.pxi", + "src/pyscipopt/nodesel.pxi", + "type.pxd", + "bool.pxd", + "complex.pxd", +}; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_obj_9pyscipopt_4scip_Expr; +struct __pyx_obj_9pyscipopt_4scip_Event; +struct __pyx_obj_9pyscipopt_4scip_Column; +struct __pyx_obj_9pyscipopt_4scip_Row; +struct __pyx_obj_9pyscipopt_4scip_NLRow; +struct __pyx_obj_9pyscipopt_4scip_Solution; +struct __pyx_obj_9pyscipopt_4scip_DomainChanges; +struct __pyx_obj_9pyscipopt_4scip_BoundChange; +struct __pyx_obj_9pyscipopt_4scip_Node; +struct __pyx_obj_9pyscipopt_4scip_Variable; +struct __pyx_obj_9pyscipopt_4scip_Constraint; +struct __pyx_obj_9pyscipopt_4scip_Model; +struct __pyx_obj_9pyscipopt_4scip_ExprCons; +struct __pyx_obj_9pyscipopt_4scip_GenExpr; +struct __pyx_obj_9pyscipopt_4scip_SumExpr; +struct __pyx_obj_9pyscipopt_4scip_ProdExpr; +struct __pyx_obj_9pyscipopt_4scip_VarExpr; +struct __pyx_obj_9pyscipopt_4scip_PowExpr; +struct __pyx_obj_9pyscipopt_4scip_UnaryExpr; +struct __pyx_obj_9pyscipopt_4scip_Constant; +struct __pyx_obj_9pyscipopt_4scip_LP; +struct __pyx_obj_9pyscipopt_4scip_Benders; +struct __pyx_obj_9pyscipopt_4scip_Benderscut; +struct __pyx_obj_9pyscipopt_4scip_Branchrule; +struct __pyx_obj_9pyscipopt_4scip_Conshdlr; +struct __pyx_obj_9pyscipopt_4scip_Cutsel; +struct __pyx_obj_9pyscipopt_4scip_Eventhdlr; +struct __pyx_obj_9pyscipopt_4scip_Heur; +struct __pyx_obj_9pyscipopt_4scip_Presol; +struct __pyx_obj_9pyscipopt_4scip_Pricer; +struct __pyx_obj_9pyscipopt_4scip_Prop; +struct __pyx_obj_9pyscipopt_4scip_Sepa; +struct __pyx_obj_9pyscipopt_4scip_Reader; +struct __pyx_obj_9pyscipopt_4scip_Relax; +struct __pyx_obj_9pyscipopt_4scip_Nodesel; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE; +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE; +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr; +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr; +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr; +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr; +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__; +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr; +struct __pyx_opt_args_7cpython_11contextvars_get_value; +struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default; + +/* "cpython/contextvars.pxd":112 + * + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, + */ +struct __pyx_opt_args_7cpython_11contextvars_get_value { + int __pyx_n; + PyObject *default_value; +}; + +/* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ +struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default { + int __pyx_n; + PyObject *default_value; +}; + +/* "pyscipopt/scip.pxd":1866 + * int SCIPtpiGetNumThreads() + * + * cdef class Expr: # <<<<<<<<<<<<<< + * cdef public terms + * + */ +struct __pyx_obj_9pyscipopt_4scip_Expr { + PyObject_HEAD + PyObject *terms; +}; + + +/* "pyscipopt/scip.pxd":1869 + * cdef public terms + * + * cdef class Event: # <<<<<<<<<<<<<< + * cdef SCIP_EVENT* event + * # can be used to store problem data + */ +struct __pyx_obj_9pyscipopt_4scip_Event { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_Event *__pyx_vtab; + SCIP_EVENT *event; + PyObject *data; +}; + + +/* "pyscipopt/scip.pxd":1876 + * cdef create(SCIP_EVENT* scip_event) + * + * cdef class Column: # <<<<<<<<<<<<<< + * cdef SCIP_COL* scip_col + * # can be used to store problem data + */ +struct __pyx_obj_9pyscipopt_4scip_Column { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_Column *__pyx_vtab; + SCIP_COL *scip_col; + PyObject *data; +}; + + +/* "pyscipopt/scip.pxd":1884 + * cdef create(SCIP_COL* scipcol) + * + * cdef class Row: # <<<<<<<<<<<<<< + * cdef SCIP_ROW* scip_row + * # can be used to store problem data + */ +struct __pyx_obj_9pyscipopt_4scip_Row { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_Row *__pyx_vtab; + SCIP_ROW *scip_row; + PyObject *data; +}; + + +/* "pyscipopt/scip.pxd":1892 + * cdef create(SCIP_ROW* sciprow) + * + * cdef class NLRow: # <<<<<<<<<<<<<< + * cdef SCIP_NLROW* scip_nlrow + * # can be used to store problem data + */ +struct __pyx_obj_9pyscipopt_4scip_NLRow { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_NLRow *__pyx_vtab; + SCIP_NLROW *scip_nlrow; + PyObject *data; +}; + + +/* "pyscipopt/scip.pxd":1900 + * cdef create(SCIP_NLROW* scipnlrow) + * + * cdef class Solution: # <<<<<<<<<<<<<< + * cdef SCIP_SOL* sol + * cdef SCIP* scip + */ +struct __pyx_obj_9pyscipopt_4scip_Solution { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_Solution *__pyx_vtab; + SCIP_SOL *sol; + SCIP *scip; + PyObject *data; +}; + + +/* "pyscipopt/scip.pxd":1909 + * cdef create(SCIP* scip, SCIP_SOL* scip_sol) + * + * cdef class DomainChanges: # <<<<<<<<<<<<<< + * cdef SCIP_DOMCHG* scip_domchg + * + */ +struct __pyx_obj_9pyscipopt_4scip_DomainChanges { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_DomainChanges *__pyx_vtab; + SCIP_DOMCHG *scip_domchg; +}; + + +/* "pyscipopt/scip.pxd":1915 + * cdef create(SCIP_DOMCHG* scip_domchg) + * + * cdef class BoundChange: # <<<<<<<<<<<<<< + * cdef SCIP_BOUNDCHG* scip_boundchg + * + */ +struct __pyx_obj_9pyscipopt_4scip_BoundChange { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_BoundChange *__pyx_vtab; + SCIP_BOUNDCHG *scip_boundchg; +}; + + +/* "pyscipopt/scip.pxd":1921 + * cdef create(SCIP_BOUNDCHG* scip_boundchg) + * + * cdef class Node: # <<<<<<<<<<<<<< + * cdef SCIP_NODE* scip_node + * # can be used to store problem data + */ +struct __pyx_obj_9pyscipopt_4scip_Node { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_Node *__pyx_vtab; + SCIP_NODE *scip_node; + PyObject *data; +}; + + +/* "pyscipopt/scip.pxd":1929 + * cdef create(SCIP_NODE* scipnode) + * + * cdef class Variable(Expr): # <<<<<<<<<<<<<< + * cdef SCIP_VAR* scip_var + * # can be used to store problem data + */ +struct __pyx_obj_9pyscipopt_4scip_Variable { + struct __pyx_obj_9pyscipopt_4scip_Expr __pyx_base; + struct __pyx_vtabstruct_9pyscipopt_4scip_Variable *__pyx_vtab; + SCIP_VAR *scip_var; + PyObject *data; +}; + + +/* "pyscipopt/scip.pxd":1937 + * cdef create(SCIP_VAR* scipvar) + * + * cdef class Constraint: # <<<<<<<<<<<<<< + * cdef SCIP_CONS* scip_cons + * # can be used to store problem data + */ +struct __pyx_obj_9pyscipopt_4scip_Constraint { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_Constraint *__pyx_vtab; + SCIP_CONS *scip_cons; + PyObject *data; +}; + + +/* "pyscipopt/scip.pxd":1945 + * cdef create(SCIP_CONS* scipcons) + * + * cdef class Model: # <<<<<<<<<<<<<< + * cdef SCIP* _scip + * cdef SCIP_Bool* _valid + */ +struct __pyx_obj_9pyscipopt_4scip_Model { + PyObject_HEAD + struct __pyx_vtabstruct_9pyscipopt_4scip_Model *__pyx_vtab; + SCIP *_scip; + SCIP_Bool *_valid; + struct __pyx_obj_9pyscipopt_4scip_Solution *_bestSol; + PyObject *data; + PyObject *__weakref__; + SCIP_Bool _freescip; + PyObject *_modelvars; +}; + + +/* "src/pyscipopt/expr.pxi":287 + * + * + * cdef class ExprCons: # <<<<<<<<<<<<<< + * '''Constraints with a polynomial expressions and lower/upper bounds.''' + * cdef public expr + */ +struct __pyx_obj_9pyscipopt_4scip_ExprCons { + PyObject_HEAD + PyObject *expr; + PyObject *_lhs; + PyObject *_rhs; +}; + + +/* "src/pyscipopt/expr.pxi":395 + * # + * #See also the @ref ExprDetails "description" in the expr.pxi. + * cdef class GenExpr: # <<<<<<<<<<<<<< + * cdef public _op + * cdef public children + */ +struct __pyx_obj_9pyscipopt_4scip_GenExpr { + PyObject_HEAD + PyObject *_op; + PyObject *children; +}; + + +/* "src/pyscipopt/expr.pxi":562 + * + * # Sum Expressions + * cdef class SumExpr(GenExpr): # <<<<<<<<<<<<<< + * + * cdef public constant + */ +struct __pyx_obj_9pyscipopt_4scip_SumExpr { + struct __pyx_obj_9pyscipopt_4scip_GenExpr __pyx_base; + PyObject *constant; + PyObject *coefs; +}; + + +/* "src/pyscipopt/expr.pxi":576 + * + * # Prod Expressions + * cdef class ProdExpr(GenExpr): # <<<<<<<<<<<<<< + * cdef public constant + * def __init__(self): + */ +struct __pyx_obj_9pyscipopt_4scip_ProdExpr { + struct __pyx_obj_9pyscipopt_4scip_GenExpr __pyx_base; + PyObject *constant; +}; + + +/* "src/pyscipopt/expr.pxi":586 + * + * # Var Expressions + * cdef class VarExpr(GenExpr): # <<<<<<<<<<<<<< + * cdef public var + * def __init__(self, var): + */ +struct __pyx_obj_9pyscipopt_4scip_VarExpr { + struct __pyx_obj_9pyscipopt_4scip_GenExpr __pyx_base; + PyObject *var; +}; + + +/* "src/pyscipopt/expr.pxi":595 + * + * # Pow Expressions + * cdef class PowExpr(GenExpr): # <<<<<<<<<<<<<< + * cdef public expo + * def __init__(self): + */ +struct __pyx_obj_9pyscipopt_4scip_PowExpr { + struct __pyx_obj_9pyscipopt_4scip_GenExpr __pyx_base; + PyObject *expo; +}; + + +/* "src/pyscipopt/expr.pxi":605 + * + * # Exp, Log, Sqrt, Sin, Cos Expressions + * cdef class UnaryExpr(GenExpr): # <<<<<<<<<<<<<< + * def __init__(self, op, expr): + * self.children = [] + */ +struct __pyx_obj_9pyscipopt_4scip_UnaryExpr { + struct __pyx_obj_9pyscipopt_4scip_GenExpr __pyx_base; +}; + + +/* "src/pyscipopt/expr.pxi":614 + * + * # class for constant expressions + * cdef class Constant(GenExpr): # <<<<<<<<<<<<<< + * cdef public number + * def __init__(self,number): + */ +struct __pyx_obj_9pyscipopt_4scip_Constant { + struct __pyx_obj_9pyscipopt_4scip_GenExpr __pyx_base; + PyObject *number; +}; + + +/* "src/pyscipopt/lp.pxi":3 + * ##@file lp.pxi + * #@brief Base class of the LP Plugin + * cdef class LP: # <<<<<<<<<<<<<< + * cdef SCIP_LPI* lpi + * cdef readonly str name + */ +struct __pyx_obj_9pyscipopt_4scip_LP { + PyObject_HEAD + SCIP_LPI *lpi; + PyObject *name; +}; + + +/* "src/pyscipopt/benders.pxi":3 + * ##@file benders.pxi + * #@brief Base class of the Benders decomposition Plugin + * cdef class Benders: # <<<<<<<<<<<<<< + * cdef public Model model + * cdef public str name + */ +struct __pyx_obj_9pyscipopt_4scip_Benders { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; + PyObject *name; + SCIP_BENDERS *_benders; +}; + + +/* "src/pyscipopt/benderscut.pxi":3 + * ##@file benderscut.pxi + * #@brief Base class of the Benderscut Plugin + * cdef class Benderscut: # <<<<<<<<<<<<<< + * cdef public Model model + * cdef public Benders benders + */ +struct __pyx_obj_9pyscipopt_4scip_Benderscut { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; + struct __pyx_obj_9pyscipopt_4scip_Benders *benders; + PyObject *name; +}; + + +/* "src/pyscipopt/branchrule.pxi":3 + * ##@file branchrule.pxi + * #@brief Base class of the Branchrule Plugin + * cdef class Branchrule: # <<<<<<<<<<<<<< + * cdef public Model model + * + */ +struct __pyx_obj_9pyscipopt_4scip_Branchrule { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; +}; + + +/* "src/pyscipopt/conshdlr.pxi":4 + * #@brief base class of the Constraint Handler plugin + * + * cdef class Conshdlr: # <<<<<<<<<<<<<< + * cdef public Model model + * cdef public str name + */ +struct __pyx_obj_9pyscipopt_4scip_Conshdlr { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; + PyObject *name; +}; + + +/* "src/pyscipopt/cutsel.pxi":3 + * ##@file cutsel.pxi + * #@brief Base class of the Cutsel Plugin + * cdef class Cutsel: # <<<<<<<<<<<<<< + * cdef public Model model + * + */ +struct __pyx_obj_9pyscipopt_4scip_Cutsel { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; +}; + + +/* "src/pyscipopt/event.pxi":3 + * ##@file event.pxi + * #@brief Base class of the Event Handler Plugin + * cdef class Eventhdlr: # <<<<<<<<<<<<<< + * cdef public Model model + * cdef public str name + */ +struct __pyx_obj_9pyscipopt_4scip_Eventhdlr { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; + PyObject *name; +}; + + +/* "src/pyscipopt/heuristic.pxi":3 + * ##@file heuristic.pxi + * #@brief Base class of the Heuristics Plugin + * cdef class Heur: # <<<<<<<<<<<<<< + * cdef public Model model + * cdef public str name + */ +struct __pyx_obj_9pyscipopt_4scip_Heur { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; + PyObject *name; +}; + + +/* "src/pyscipopt/presol.pxi":3 + * ##@file presol.pxi + * #@brief Base class of the Presolver Plugin + * cdef class Presol: # <<<<<<<<<<<<<< + * cdef public Model model + * + */ +struct __pyx_obj_9pyscipopt_4scip_Presol { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; +}; + + +/* "src/pyscipopt/pricer.pxi":3 + * ##@file pricer.pxi + * #@brief Base class of the Pricers Plugin + * cdef class Pricer: # <<<<<<<<<<<<<< + * cdef public Model model + * + */ +struct __pyx_obj_9pyscipopt_4scip_Pricer { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; +}; + + +/* "src/pyscipopt/propagator.pxi":3 + * ##@file propagator.pxi + * #@brief Base class of the Propagators Plugin + * cdef class Prop: # <<<<<<<<<<<<<< + * cdef public Model model + * + */ +struct __pyx_obj_9pyscipopt_4scip_Prop { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; +}; + + +/* "src/pyscipopt/sepa.pxi":3 + * ##@file sepa.pxi + * #@brief Base class of the Separator Plugin + * cdef class Sepa: # <<<<<<<<<<<<<< + * cdef public Model model + * cdef public str name + */ +struct __pyx_obj_9pyscipopt_4scip_Sepa { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; + PyObject *name; +}; + + +/* "src/pyscipopt/reader.pxi":3 + * ##@file reader.pxi + * #@brief Base class of the Reader Plugin + * cdef class Reader: # <<<<<<<<<<<<<< + * cdef public Model model + * cdef public str name + */ +struct __pyx_obj_9pyscipopt_4scip_Reader { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; + PyObject *name; +}; + + +/* "src/pyscipopt/relax.pxi":3 + * ##@file relax.pxi + * #@brief Base class of the Relaxator Plugin + * cdef class Relax: # <<<<<<<<<<<<<< + * cdef public Model model + * cdef public str name + */ +struct __pyx_obj_9pyscipopt_4scip_Relax { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; + PyObject *name; +}; + + +/* "src/pyscipopt/nodesel.pxi":3 + * ##@file nodesel.pxi + * #@brief Base class of the Nodesel Plugin + * cdef class Nodesel: # <<<<<<<<<<<<<< + * cdef public Model model + * + */ +struct __pyx_obj_9pyscipopt_4scip_Nodesel { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Model *model; +}; + + +/* "src/pyscipopt/scip.pxi":58 + * # In __init__.py this is imported as SCIP_RESULT to keep the + * # original naming scheme using capital letters + * cdef class PY_SCIP_RESULT: # <<<<<<<<<<<<<< + * DIDNOTRUN = SCIP_DIDNOTRUN + * DELAYED = SCIP_DELAYED + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":77 + * SUCCESS = SCIP_SUCCESS + * + * cdef class PY_SCIP_PARAMSETTING: # <<<<<<<<<<<<<< + * DEFAULT = SCIP_PARAMSETTING_DEFAULT + * AGGRESSIVE = SCIP_PARAMSETTING_AGGRESSIVE + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":83 + * OFF = SCIP_PARAMSETTING_OFF + * + * cdef class PY_SCIP_PARAMEMPHASIS: # <<<<<<<<<<<<<< + * DEFAULT = SCIP_PARAMEMPHASIS_DEFAULT + * CPSOLVER = SCIP_PARAMEMPHASIS_CPSOLVER + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":97 + * BENCHMARK = SCIP_PARAMEMPHASIS_BENCHMARK + * + * cdef class PY_SCIP_STATUS: # <<<<<<<<<<<<<< + * UNKNOWN = SCIP_STATUS_UNKNOWN + * USERINTERRUPT = SCIP_STATUS_USERINTERRUPT + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":118 + * StageNames = {} + * + * cdef class PY_SCIP_STAGE: # <<<<<<<<<<<<<< + * INIT = SCIP_STAGE_INIT + * PROBLEM = SCIP_STAGE_PROBLEM + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":134 + * FREE = SCIP_STAGE_FREE + * + * cdef class PY_SCIP_NODETYPE: # <<<<<<<<<<<<<< + * FOCUSNODE = SCIP_NODETYPE_FOCUSNODE + * PROBINGNODE = SCIP_NODETYPE_PROBINGNODE + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":148 + * + * + * cdef class PY_SCIP_PROPTIMING: # <<<<<<<<<<<<<< + * BEFORELP = SCIP_PROPTIMING_BEFORELP + * DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":154 + * AFTERLPNODE = SCIP_PROPTIMING_AFTERLPNODE + * + * cdef class PY_SCIP_PRESOLTIMING: # <<<<<<<<<<<<<< + * NONE = SCIP_PRESOLTIMING_NONE + * FAST = SCIP_PRESOLTIMING_FAST + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":160 + * EXHAUSTIVE = SCIP_PRESOLTIMING_EXHAUSTIVE + * + * cdef class PY_SCIP_HEURTIMING: # <<<<<<<<<<<<<< + * BEFORENODE = SCIP_HEURTIMING_BEFORENODE + * DURINGLPLOOP = SCIP_HEURTIMING_DURINGLPLOOP + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":175 + * EventNames = {} + * + * cdef class PY_SCIP_EVENTTYPE: # <<<<<<<<<<<<<< + * DISABLED = SCIP_EVENTTYPE_DISABLED + * VARADDED = SCIP_EVENTTYPE_VARADDED + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":232 + * + * + * cdef class PY_SCIP_LPSOLSTAT: # <<<<<<<<<<<<<< + * NOTSOLVED = SCIP_LPSOLSTAT_NOTSOLVED + * OPTIMAL = SCIP_LPSOLSTAT_OPTIMAL + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":242 + * ERROR = SCIP_LPSOLSTAT_ERROR + * + * cdef class PY_SCIP_BRANCHDIR: # <<<<<<<<<<<<<< + * DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS + * UPWARDS = SCIP_BRANCHDIR_UPWARDS + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":248 + * AUTO = SCIP_BRANCHDIR_AUTO + * + * cdef class PY_SCIP_BENDERSENFOTYPE: # <<<<<<<<<<<<<< + * LP = SCIP_BENDERSENFOTYPE_LP + * RELAX = SCIP_BENDERSENFOTYPE_RELAX + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE { + PyObject_HEAD +}; + + +/* "src/pyscipopt/scip.pxi":254 + * CHECK = SCIP_BENDERSENFOTYPE_CHECK + * + * cdef class PY_SCIP_ROWORIGINTYPE: # <<<<<<<<<<<<<< + * UNSPEC = SCIP_ROWORIGINTYPE_UNSPEC + * CONS = SCIP_ROWORIGINTYPE_CONS + */ +struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE { + PyObject_HEAD +}; + + +/* "src/pyscipopt/expr.pxi":90 + * def __init__(self, *vartuple): + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) # <<<<<<<<<<<<<< + * self.hashval = sum(self.ptrtuple) + * + */ +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_v; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_t_2)(PyObject *); +}; + + +/* "src/pyscipopt/expr.pxi":284 + * return 0 + * else: + * return max(len(v) for v in self.terms) # <<<<<<<<<<<<<< + * + * + */ +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_v; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_t_2)(PyObject *); +}; + + +/* "src/pyscipopt/lp.pxi":100 + * + * ncols = len(entrieslist) + * nnonz = sum(len(entries) for entries in entrieslist) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_objs = malloc(ncols * sizeof(SCIP_Real)) + */ +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_entries; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_t_2)(PyObject *); +}; + + +/* "src/pyscipopt/lp.pxi":192 + * """ + * nrows = len(entrieslist) + * nnonz = sum(len(entries) for entries in entrieslist) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + */ +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_entries; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + PyObject *(*__pyx_t_2)(PyObject *); +}; + + +/* "src/pyscipopt/scip.pxi":594 + * return sol + * + * def __getitem__(self, Expr expr): # <<<<<<<<<<<<<< + * # fast track for Variable + * if isinstance(expr, Variable): + */ +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self; +}; + + +/* "src/pyscipopt/scip.pxi":600 + * var = expr + * return SCIPgetSolVal(self.scip, self.sol, var.scip_var) + * return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0) # <<<<<<<<<<<<<< + * + * def _evaluate(self, term): + */ +struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr { + PyObject_HEAD + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *__pyx_outer_scope; + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_coeff; + PyObject *__pyx_v_term; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; +}; + + + +/* "src/pyscipopt/scip.pxi":301 + * raise Exception('SCIP: unknown return code!') + * + * cdef class Event: # <<<<<<<<<<<<<< + * """Base class holding a pointer to corresponding SCIP_EVENT""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_Event { + PyObject *(*create)(SCIP_EVENT *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_Event *__pyx_vtabptr_9pyscipopt_4scip_Event; + + +/* "src/pyscipopt/scip.pxi":365 + * and self.event == (other).event) + * + * cdef class Column: # <<<<<<<<<<<<<< + * """Base class holding a pointer to corresponding SCIP_COL""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_Column { + PyObject *(*create)(SCIP_COL *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_Column *__pyx_vtabptr_9pyscipopt_4scip_Column; + + +/* "src/pyscipopt/scip.pxi":426 + * and self.scip_col == (other).scip_col) + * + * cdef class Row: # <<<<<<<<<<<<<< + * """Base class holding a pointer to corresponding SCIP_ROW""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_Row { + PyObject *(*create)(SCIP_ROW *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_Row *__pyx_vtabptr_9pyscipopt_4scip_Row; + + +/* "src/pyscipopt/scip.pxi":531 + * and self.scip_row == (other).scip_row) + * + * cdef class NLRow: # <<<<<<<<<<<<<< + * """Base class holding a pointer to corresponding SCIP_NLROW""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_NLRow { + PyObject *(*create)(SCIP_NLROW *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_NLRow *__pyx_vtabptr_9pyscipopt_4scip_NLRow; + + +/* "src/pyscipopt/scip.pxi":577 + * and self.scip_nlrow == (other).scip_nlrow) + * + * cdef class Solution: # <<<<<<<<<<<<<< + * """Base class holding a pointer to corresponding SCIP_SOL""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_Solution { + PyObject *(*create)(SCIP *, SCIP_SOL *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_Solution *__pyx_vtabptr_9pyscipopt_4scip_Solution; + + +/* "src/pyscipopt/scip.pxi":669 + * self.getNewBound()) + * + * cdef class DomainChanges: # <<<<<<<<<<<<<< + * """Set of domain changes.""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_DomainChanges { + PyObject *(*create)(SCIP_DOMCHG *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_DomainChanges *__pyx_vtabptr_9pyscipopt_4scip_DomainChanges; + + +/* "src/pyscipopt/scip.pxi":633 + * + * + * cdef class BoundChange: # <<<<<<<<<<<<<< + * """Bound change.""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_BoundChange { + PyObject *(*create)(SCIP_BOUNDCHG *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_BoundChange *__pyx_vtabptr_9pyscipopt_4scip_BoundChange; + + +/* "src/pyscipopt/scip.pxi":686 + * for i in range(nboundchgs)] + * + * cdef class Node: # <<<<<<<<<<<<<< + * """Base class holding a pointer to corresponding SCIP_NODE""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_Node { + PyObject *(*create)(SCIP_NODE *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_Node *__pyx_vtabptr_9pyscipopt_4scip_Node; + + +/* "src/pyscipopt/scip.pxi":804 + * and self.scip_node == (other).scip_node) + * + * cdef class Variable(Expr): # <<<<<<<<<<<<<< + * """Is a linear expression and has SCIP_VAR*""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_Variable { + PyObject *(*create)(SCIP_VAR *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_Variable *__pyx_vtabptr_9pyscipopt_4scip_Variable; + + +/* "src/pyscipopt/scip.pxi":891 + * return SCIPvarGetLPSol(self.scip_var) + * + * cdef class Constraint: # <<<<<<<<<<<<<< + * """Base class holding a pointer to corresponding SCIP_CONS""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_Constraint { + PyObject *(*create)(SCIP_CONS *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_Constraint *__pyx_vtabptr_9pyscipopt_4scip_Constraint; + + +/* "src/pyscipopt/scip.pxi":993 + * #@anchor Model + * ## + * cdef class Model: # <<<<<<<<<<<<<< + * """Main class holding a pointer to SCIP for managing most interactions""" + * + */ + +struct __pyx_vtabstruct_9pyscipopt_4scip_Model { + PyObject *(*create)(SCIP *); +}; +static struct __pyx_vtabstruct_9pyscipopt_4scip_Model *__pyx_vtabptr_9pyscipopt_4scip_Model; +/* #### Code section: utility_code_proto ### */ + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() +#endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywords.proto */ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, + const char* function_name); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif +#endif +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* pybytes_as_double.proto */ +static double __Pyx_SlowPyString_AsDouble(PyObject *obj); +static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length); +static CYTHON_INLINE double __Pyx_PyBytes_AsDouble(PyObject *obj) { + char* as_c_string; + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + as_c_string = PyBytes_AS_STRING(obj); + size = PyBytes_GET_SIZE(obj); +#else + if (PyBytes_AsStringAndSize(obj, &as_c_string, &size) < 0) { + return (double)-1; + } +#endif + return __Pyx__PyBytes_AsDouble(obj, as_c_string, size); +} +static CYTHON_INLINE double __Pyx_PyByteArray_AsDouble(PyObject *obj) { + char* as_c_string; + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + as_c_string = PyByteArray_AS_STRING(obj); + size = PyByteArray_GET_SIZE(obj); +#else + as_c_string = PyByteArray_AsString(obj); + if (as_c_string == NULL) { + return (double)-1; + } + size = PyByteArray_Size(obj); +#endif + return __Pyx__PyBytes_AsDouble(obj, as_c_string, size); +} + +/* pyunicode_as_double.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS +static const char* __Pyx__PyUnicode_AsDouble_Copy(const void* data, const int kind, char* buffer, Py_ssize_t start, Py_ssize_t end) { + int last_was_punctuation; + Py_ssize_t i; + last_was_punctuation = 1; + for (i=start; i <= end; i++) { + Py_UCS4 chr = PyUnicode_READ(kind, data, i); + int is_punctuation = (chr == '_') | (chr == '.'); + *buffer = (char)chr; + buffer += (chr != '_'); + if (unlikely(chr > 127)) goto parse_failure; + if (unlikely(last_was_punctuation & is_punctuation)) goto parse_failure; + last_was_punctuation = is_punctuation; + } + if (unlikely(last_was_punctuation)) goto parse_failure; + *buffer = '\0'; + return buffer; +parse_failure: + return NULL; +} +static double __Pyx__PyUnicode_AsDouble_inf_nan(const void* data, int kind, Py_ssize_t start, Py_ssize_t length) { + int matches = 1; + Py_UCS4 chr; + Py_UCS4 sign = PyUnicode_READ(kind, data, start); + int is_signed = (sign == '-') | (sign == '+'); + start += is_signed; + length -= is_signed; + switch (PyUnicode_READ(kind, data, start)) { + #ifdef Py_NAN + case 'n': + case 'N': + if (unlikely(length != 3)) goto parse_failure; + chr = PyUnicode_READ(kind, data, start+1); + matches &= (chr == 'a') | (chr == 'A'); + chr = PyUnicode_READ(kind, data, start+2); + matches &= (chr == 'n') | (chr == 'N'); + if (unlikely(!matches)) goto parse_failure; + return (sign == '-') ? -Py_NAN : Py_NAN; + #endif + case 'i': + case 'I': + if (unlikely(length < 3)) goto parse_failure; + chr = PyUnicode_READ(kind, data, start+1); + matches &= (chr == 'n') | (chr == 'N'); + chr = PyUnicode_READ(kind, data, start+2); + matches &= (chr == 'f') | (chr == 'F'); + if (likely(length == 3 && matches)) + return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; + if (unlikely(length != 8)) goto parse_failure; + chr = PyUnicode_READ(kind, data, start+3); + matches &= (chr == 'i') | (chr == 'I'); + chr = PyUnicode_READ(kind, data, start+4); + matches &= (chr == 'n') | (chr == 'N'); + chr = PyUnicode_READ(kind, data, start+5); + matches &= (chr == 'i') | (chr == 'I'); + chr = PyUnicode_READ(kind, data, start+6); + matches &= (chr == 't') | (chr == 'T'); + chr = PyUnicode_READ(kind, data, start+7); + matches &= (chr == 'y') | (chr == 'Y'); + if (unlikely(!matches)) goto parse_failure; + return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL; + case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': + break; + default: + goto parse_failure; + } + return 0.0; +parse_failure: + return -1.0; +} +static double __Pyx_PyUnicode_AsDouble_WithSpaces(PyObject *obj) { + double value; + const char *last; + char *end; + Py_ssize_t start, length = PyUnicode_GET_LENGTH(obj); + const int kind = PyUnicode_KIND(obj); + const void* data = PyUnicode_DATA(obj); + start = 0; + while (Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, start))) + start++; + while (start < length - 1 && Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, length - 1))) + length--; + length -= start; + if (unlikely(length <= 0)) goto fallback; + value = __Pyx__PyUnicode_AsDouble_inf_nan(data, kind, start, length); + if (unlikely(value == -1.0)) goto fallback; + if (value != 0.0) return value; + if (length < 40) { + char number[40]; + last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length); + if (unlikely(!last)) goto fallback; + value = PyOS_string_to_double(number, &end, NULL); + } else { + char *number = (char*) PyMem_Malloc((length + 1) * sizeof(char)); + if (unlikely(!number)) goto fallback; + last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length); + if (unlikely(!last)) { + PyMem_Free(number); + goto fallback; + } + value = PyOS_string_to_double(number, &end, NULL); + PyMem_Free(number); + } + if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) { + return value; + } +fallback: + return __Pyx_SlowPyString_AsDouble(obj); +} +#endif +static CYTHON_INLINE double __Pyx_PyUnicode_AsDouble(PyObject *obj) { +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS + if (unlikely(__Pyx_PyUnicode_READY(obj) == -1)) + return (double)-1; + if (likely(PyUnicode_IS_ASCII(obj))) { + const char *s; + Py_ssize_t length; + s = PyUnicode_AsUTF8AndSize(obj, &length); + return __Pyx__PyBytes_AsDouble(obj, s, length); + } + return __Pyx_PyUnicode_AsDouble_WithSpaces(obj); +#else + return __Pyx_SlowPyString_AsDouble(obj); +#endif +} + +/* pyobject_as_double.proto */ +static double __Pyx__PyObject_AsDouble(PyObject* obj); +#if CYTHON_COMPILING_IN_PYPY +#define __Pyx_PyObject_AsDouble(obj)\ +(likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) :\ + likely(PyInt_CheckExact(obj)) ?\ + PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) +#else +#define __Pyx_PyObject_AsDouble(obj)\ +((likely(PyFloat_CheckExact(obj))) ? PyFloat_AS_DOUBLE(obj) :\ + likely(PyLong_CheckExact(obj)) ?\ + PyLong_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj)) +#endif + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* PyIntCompare.proto */ +static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* pynumber_float.proto */ +static CYTHON_INLINE PyObject* __Pyx__PyNumber_Float(PyObject* obj); +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : __Pyx__PyNumber_Float(x)) + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyFloatBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyFloat_EqObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyFloat_EqObjC(op1, op2, floatval, inplace, zerodivision_check)\ + (PyObject_RichCompare(op1, op2, Py_EQ)) + #endif + +/* RaiseUnboundLocalError.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* pep479.proto */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); + +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* PyObjectSetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* PyObject_Str.proto */ +#define __Pyx_PyObject_Str(obj)\ + (likely(PyString_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* PyObjectGetMethod.proto */ +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* UnpackTupleError.proto */ +static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); + +/* UnpackTuple2.proto */ +#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ + (likely(is_tuple || PyTuple_Check(tuple)) ?\ + (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ + __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ + (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ + __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); +static int __Pyx_unpack_tuple2_generic( + PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); + +/* dict_iter.proto */ +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_is_dict); +static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); + +/* AssertionsEnabled.proto */ +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (1) +#elif CYTHON_COMPILING_IN_LIMITED_API || (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000) + static int __pyx_assertions_enabled_flag; + #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) + static int __Pyx_init_assertions_enabled(void) { + PyObject *builtins, *debug, *debug_str; + int flag; + builtins = PyEval_GetBuiltins(); + if (!builtins) goto bad; + debug_str = PyUnicode_FromStringAndSize("__debug__", 9); + if (!debug_str) goto bad; + debug = PyObject_GetItem(builtins, debug_str); + Py_DECREF(debug_str); + if (!debug) goto bad; + flag = PyObject_IsTrue(debug); + Py_DECREF(debug); + if (flag == -1) goto bad; + __pyx_assertions_enabled_flag = flag; + return 0; + bad: + __pyx_assertions_enabled_flag = 1; + return -1; + } +#else + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (!Py_OptimizeFlag) +#endif + +/* IterNext.proto */ +#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL) +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); + +/* py_abs.proto */ +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject *__Pyx_PyLong_AbsNeg(PyObject *num); +#define __Pyx_PyNumber_Absolute(x)\ + ((likely(PyLong_CheckExact(x))) ?\ + (likely(__Pyx_PyLong_IsNonNeg(x)) ? (Py_INCREF(x), (x)) : __Pyx_PyLong_AbsNeg(x)) :\ + PyNumber_Absolute(x)) +#else +#define __Pyx_PyNumber_Absolute(x) PyNumber_Absolute(x) +#endif + +/* dict_getitem_default.proto */ +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; + +/* CallUnboundCMethod1.proto */ +static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); +#else +#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) +#endif + +/* CallUnboundCMethod2.proto */ +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + +/* KeywordStringCheck.proto */ +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); + +/* PyFloatBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static int __Pyx_PyFloat_BoolNeObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyFloat_BoolNeObjC(op1, op2, floatval, inplace, zerodivision_check)\ + __Pyx_PyObject_IsTrueAndDecref(PyObject_RichCompare(op1, op2, Py_NE)) + #endif + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); + +/* PyFloatBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static int __Pyx_PyFloat_BoolEqObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyFloat_BoolEqObjC(op1, op2, floatval, inplace, zerodivision_check)\ + __Pyx_PyObject_IsTrueAndDecref(PyObject_RichCompare(op1, op2, Py_EQ)) + #endif + +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); + +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* PyObjectCall2Args.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* append.proto */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); + +/* WriteUnraisableException.proto */ +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* DictGetItem.proto */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/* decode_c_string_utf16.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/* decode_c_string.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* decode_c_bytes.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* decode_bytes.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_bytes( + PyObject* string, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + char* as_c_string; + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + as_c_string = PyBytes_AS_STRING(string); + size = PyBytes_GET_SIZE(string); +#else + if (PyBytes_AsStringAndSize(string, &as_c_string, &size) < 0) { + return NULL; + } +#endif + return __Pyx_decode_c_bytes( + as_c_string, size, + start, stop, encoding, errors, decode_func); +} + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* PyIntCompare.proto */ +static CYTHON_INLINE int __Pyx_PyInt_BoolNeObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +/* RaiseClosureNameError.proto */ +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); + +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif PY_MAJOR_VERSION < 3 + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif + +/* PyFloatBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyFloat_TrueDivideObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyFloat_TrueDivideObjC(op1, op2, floatval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceTrueDivide(op1, op2) : PyNumber_TrueDivide(op1, op2)) +#endif + +/* SliceObject.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( + PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); + +/* SetItemInt.proto */ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* BuildPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, + int prepend_sign, char padding_char); + +/* CIntToPyUnicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); + +/* UnicodeAsUCS4.proto */ +static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject*); + +/* object_ord.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyObject_Ord(c)\ + (likely(PyUnicode_Check(c)) ? (long)__Pyx_PyUnicode_AsPy_UCS4(c) : __Pyx__PyObject_Ord(c)) +#else +#define __Pyx_PyObject_Ord(c) __Pyx__PyObject_Ord(c) +#endif +static long __Pyx__PyObject_Ord(PyObject* c); + +/* PyObjectLookupSpecial.proto */ +#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_LookupSpecialNoError(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 0) +#define __Pyx_PyObject_LookupSpecial(obj, attr_name) __Pyx__PyObject_LookupSpecial(obj, attr_name, 1) +static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error); +#else +#define __Pyx_PyObject_LookupSpecialNoError(o,n) __Pyx_PyObject_GetAttrStrNoError(o,n) +#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* HasAttr.proto */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* PyObject_GenericGetAttrNoDict.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +#endif + +/* PyObject_GenericGetAttr.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr +#endif + +/* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce(PyObject* type_obj); +#endif + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); + +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_MergeVtables(PyTypeObject *type); +#endif + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto_3_0_10 +#define __PYX_HAVE_RT_ImportType_proto_3_0_10 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_0_10(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_0_10 { + __Pyx_ImportType_CheckSize_Error_3_0_10 = 0, + __Pyx_ImportType_CheckSize_Warn_3_0_10 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_0_10 = 2 +}; +static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size); +#endif + +/* ImportDottedModule.proto */ +static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); +#if PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); +#endif + +/* SetNameInClass.proto */ +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 +#define __Pyx_SetNameInClass(ns, name, value)\ + (likely(PyDict_CheckExact(ns)) ? _PyDict_SetItem_KnownHash(ns, name, value, ((PyASCIIObject *) name)->hash) : PyObject_SetItem(ns, name, value)) +#elif CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_SetNameInClass(ns, name, value)\ + (likely(PyDict_CheckExact(ns)) ? PyDict_SetItem(ns, name, value) : PyObject_SetItem(ns, name, value)) +#else +#define __Pyx_SetNameInClass(ns, name, value) PyObject_SetItem(ns, name, value) +#endif + +/* CalculateMetaclass.proto */ +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +/* Py3ClassCreate.proto */ +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +/* GetNameInClass.proto */ +#define __Pyx_GetNameInClass(var, nmspace, name) (var) = __Pyx__GetNameInClass(nmspace, name) +static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); +#endif + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_BOUNDTYPE(SCIP_BOUNDTYPE value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_RESULT(SCIP_RESULT value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_PARAMSETTING(SCIP_PARAMSETTING value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_PROPTIMING(SCIP_PROPTIMING value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_BRANCHDIR(SCIP_BRANCHDIR value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(SCIP_BENDERSENFOTYPE value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_ROWORIGINTYPE(SCIP_ROWORIGINTYPE value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_RETCODE __Pyx_PyInt_As_SCIP_RETCODE(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_RETCODE(SCIP_RETCODE value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_RESULT __Pyx_PyInt_As_SCIP_RESULT(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_LOCKTYPE(SCIP_LOCKTYPE value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_OBJSENSE(SCIP_OBJSENSE value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_BOUNDCHGTYPE(SCIP_BOUNDCHGTYPE value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_Longint(SCIP_Longint value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_PARAMSETTING __Pyx_PyInt_As_SCIP_PARAMSETTING(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_BENDERSENFOTYPE __Pyx_PyInt_As_SCIP_BENDERSENFOTYPE(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_PROPTIMING __Pyx_PyInt_As_SCIP_PROPTIMING(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_PRESOLTIMING __Pyx_PyInt_As_SCIP_PRESOLTIMING(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_BRANCHDIR __Pyx_PyInt_As_SCIP_BRANCHDIR(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_EVENTTYPE __Pyx_PyInt_As_SCIP_EVENTTYPE(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_Longint __Pyx_PyInt_As_SCIP_Longint(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE SCIP_PARAMEMPHASIS __Pyx_PyInt_As_SCIP_PARAMEMPHASIS(PyObject *); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* CoroutineBase.proto */ +struct __pyx_CoroutineObject; +typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_ExcInfoStruct _PyErr_StackItem +#else +typedef struct { + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; +} __Pyx_ExcInfoStruct; +#endif +typedef struct __pyx_CoroutineObject { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + __Pyx_ExcInfoStruct gi_exc_state; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + PyObject *gi_name; + PyObject *gi_qualname; + PyObject *gi_modulename; + PyObject *gi_code; + PyObject *gi_frame; + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); +static int __Pyx_Coroutine_clear(PyObject *self); +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_Coroutine_SwapException(self) +#define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) +#else +#define __Pyx_Coroutine_SwapException(self) {\ + __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ + __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ + } +#define __Pyx_Coroutine_ResetAndClearException(self) {\ + __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ + (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ + } +#endif +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) +#endif +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); + +/* PatchModuleWithCoroutine.proto */ +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); + +/* PatchGeneratorABC.proto */ +static int __Pyx_patch_abc(void); + +/* Generator.proto */ +#define __Pyx_Generator_USED +#define __Pyx_Generator_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_GeneratorType) +#define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ + __Pyx__Coroutine_New(__pyx_GeneratorType, body, code, closure, name, qualname, module_name) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(PyObject *module); + +/* CheckBinaryVersion.proto */ +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/* InitStrings.proto */ +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +/* #### Code section: module_declarations ### */ +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_5Event_create(SCIP_EVENT *__pyx_v_scip_event); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_6Column_create(SCIP_COL *__pyx_v_scipcol); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_3Row_create(SCIP_ROW *__pyx_v_sciprow); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_5NLRow_create(SCIP_NLROW *__pyx_v_scipnlrow); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_8Solution_create(SCIP *__pyx_v_scip, SCIP_SOL *__pyx_v_scip_sol); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_11BoundChange_create(SCIP_BOUNDCHG *__pyx_v_scip_boundchg); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_13DomainChanges_create(SCIP_DOMCHG *__pyx_v_scip_domchg); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_4Node_create(SCIP_NODE *__pyx_v_scipnode); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_8Variable_create(SCIP_VAR *__pyx_v_scipvar); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_10Constraint_create(SCIP_CONS *__pyx_v_scipcons); /* proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip_5Model_create(SCIP *__pyx_v_scip); /* proto*/ + +/* Module declarations from "cython" */ + +/* Module declarations from "cpython.version" */ + +/* Module declarations from "__builtin__" */ + +/* Module declarations from "cpython.type" */ + +/* Module declarations from "libc.string" */ + +/* Module declarations from "libc.stdio" */ + +/* Module declarations from "cpython.object" */ + +/* Module declarations from "cpython.ref" */ + +/* Module declarations from "cpython.exc" */ + +/* Module declarations from "cpython.module" */ + +/* Module declarations from "cpython.mem" */ + +/* Module declarations from "cpython.tuple" */ + +/* Module declarations from "cpython.list" */ + +/* Module declarations from "cpython.sequence" */ + +/* Module declarations from "cpython.mapping" */ + +/* Module declarations from "cpython.iterator" */ + +/* Module declarations from "cpython.number" */ + +/* Module declarations from "cpython.int" */ + +/* Module declarations from "__builtin__" */ + +/* Module declarations from "cpython.bool" */ + +/* Module declarations from "cpython.long" */ + +/* Module declarations from "cpython.float" */ + +/* Module declarations from "__builtin__" */ + +/* Module declarations from "cpython.complex" */ + +/* Module declarations from "cpython.string" */ + +/* Module declarations from "libc.stddef" */ + +/* Module declarations from "cpython.unicode" */ + +/* Module declarations from "cpython.pyport" */ + +/* Module declarations from "cpython.dict" */ + +/* Module declarations from "cpython.instance" */ + +/* Module declarations from "cpython.function" */ + +/* Module declarations from "cpython.method" */ + +/* Module declarations from "cpython.weakref" */ + +/* Module declarations from "cpython.getargs" */ + +/* Module declarations from "cpython.pythread" */ + +/* Module declarations from "cpython.pystate" */ + +/* Module declarations from "cpython.cobject" */ + +/* Module declarations from "cpython.oldbuffer" */ + +/* Module declarations from "cpython.set" */ + +/* Module declarations from "cpython.buffer" */ + +/* Module declarations from "cpython.bytes" */ + +/* Module declarations from "cpython.pycapsule" */ + +/* Module declarations from "cpython.contextvars" */ + +/* Module declarations from "cpython" */ + +/* Module declarations from "libc.stdlib" */ + +/* Module declarations from "posix.types" */ + +/* Module declarations from "posix.stdio" */ + +/* Module declarations from "pyscipopt.scip" */ +static struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_f_9pyscipopt_4scip_getPyVar(SCIP_VAR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersCopy(SCIP *, SCIP_BENDERS *, SCIP_Bool); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersFree(SCIP *, SCIP_BENDERS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersInit(SCIP *, SCIP_BENDERS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersExit(SCIP *, SCIP_BENDERS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersInitpre(SCIP *, SCIP_BENDERS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersExitpre(SCIP *, SCIP_BENDERS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersInitsol(SCIP *, SCIP_BENDERS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersExitsol(SCIP *, SCIP_BENDERS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersCreatesub(SCIP *, SCIP_BENDERS *, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersPresubsolve(SCIP *, SCIP_BENDERS *, SCIP_SOL *, SCIP_BENDERSENFOTYPE, SCIP_Bool, SCIP_Bool *, SCIP_Bool *, SCIP_Bool *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersSolvesubconvex(SCIP *, SCIP_BENDERS *, SCIP_SOL *, int, SCIP_Bool, SCIP_Real *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersSolvesub(SCIP *, SCIP_BENDERS *, SCIP_SOL *, int, SCIP_Real *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersPostsolve(SCIP *, SCIP_BENDERS *, SCIP_SOL *, SCIP_BENDERSENFOTYPE, int *, int, int, SCIP_Bool, SCIP_Bool, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersFreesub(SCIP *, SCIP_BENDERS *, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersGetvar(SCIP *, SCIP_BENDERS *, SCIP_VAR *, SCIP_VAR **, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutCopy(SCIP *, SCIP_BENDERS *, SCIP_BENDERSCUT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutFree(SCIP *, SCIP_BENDERSCUT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutInit(SCIP *, SCIP_BENDERSCUT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutExit(SCIP *, SCIP_BENDERSCUT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutInitsol(SCIP *, SCIP_BENDERSCUT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutExitsol(SCIP *, SCIP_BENDERSCUT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutExec(SCIP *, SCIP_BENDERS *, SCIP_BENDERSCUT *, SCIP_SOL *, int, SCIP_BENDERSENFOTYPE, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleCopy(SCIP *, SCIP_BRANCHRULE *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleFree(SCIP *, SCIP_BRANCHRULE *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleInit(SCIP *, SCIP_BRANCHRULE *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExit(SCIP *, SCIP_BRANCHRULE *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleInitsol(SCIP *, SCIP_BRANCHRULE *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExitsol(SCIP *, SCIP_BRANCHRULE *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExeclp(SCIP *, SCIP_BRANCHRULE *, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExecext(SCIP *, SCIP_BRANCHRULE *, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExecps(SCIP *, SCIP_BRANCHRULE *, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_f_9pyscipopt_4scip_getPyConshdlr(SCIP_CONSHDLR *); /*proto*/ +static struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_f_9pyscipopt_4scip_getPyCons(SCIP_CONS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConshdlrCopy(SCIP *, SCIP_CONSHDLR *, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsFree(SCIP *, SCIP_CONSHDLR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsInit(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsExit(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsInitpre(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsExitpre(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsInitsol(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsExitsol(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, SCIP_Bool); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsDelete(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, SCIP_CONSDATA **); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsTrans(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, SCIP_CONS **); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsInitlp(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsSepalp(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, int, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsSepasol(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, int, SCIP_SOL *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsEnfolp(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, int, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsEnforelax(SCIP *, SCIP_SOL *, SCIP_CONSHDLR *, SCIP_CONS **, int, int, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsEnfops(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, int, SCIP_Bool, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsCheck(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, SCIP_SOL *, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsProp(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, int, int, SCIP_PROPTIMING, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsPresol(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int, int, SCIP_PRESOLTIMING, int, int, int, int, int, int, int, int, int, int, int *, int *, int *, int *, int *, int *, int *, int *, int *, int *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsResprop(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, SCIP_VAR *, int, SCIP_BOUNDTYPE, SCIP_BDCHGIDX *, SCIP_Real, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsLock(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, SCIP_LOCKTYPE, int, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsActive(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsDeactive(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsEnable(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsDisable(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsDelvars(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsPrint(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, FILE *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsCopy(SCIP *, SCIP_CONS **, char const *, SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, SCIP_HASHMAP *, SCIP_HASHMAP *, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsParse(SCIP *, SCIP_CONSHDLR *, SCIP_CONS **, char const *, char const *, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetvars(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, SCIP_VAR **, int, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetnvars(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, int *, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetdivebdchgs(SCIP *, SCIP_CONSHDLR *, SCIP_DIVESET *, SCIP_SOL *, SCIP_Bool *, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetPermSymGraph(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, SYM_GRAPH *, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetSignedPermSymGraph(SCIP *, SCIP_CONSHDLR *, SCIP_CONS *, SYM_GRAPH *, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselCopy(SCIP *, SCIP_CUTSEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselFree(SCIP *, SCIP_CUTSEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselInit(SCIP *, SCIP_CUTSEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselExit(SCIP *, SCIP_CUTSEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselInitsol(SCIP *, SCIP_CUTSEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselExitsol(SCIP *, SCIP_CUTSEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselSelect(SCIP *, SCIP_CUTSEL *, SCIP_ROW **, int, SCIP_ROW **, int, SCIP_Bool, int, int *, SCIP_RESULT *); /*proto*/ +static struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_f_9pyscipopt_4scip_getPyEventhdlr(SCIP_EVENTHDLR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventCopy(SCIP *, SCIP_EVENTHDLR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventFree(SCIP *, SCIP_EVENTHDLR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventInit(SCIP *, SCIP_EVENTHDLR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventExit(SCIP *, SCIP_EVENTHDLR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventInitsol(SCIP *, SCIP_EVENTHDLR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventExitsol(SCIP *, SCIP_EVENTHDLR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventDelete(SCIP *, SCIP_EVENTHDLR *, SCIP_EVENTDATA **); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventExec(SCIP *, SCIP_EVENTHDLR *, SCIP_EVENT *, SCIP_EVENTDATA *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurCopy(SCIP *, SCIP_HEUR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurFree(SCIP *, SCIP_HEUR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurInit(SCIP *, SCIP_HEUR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurExit(SCIP *, SCIP_HEUR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurInitsol(SCIP *, SCIP_HEUR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurExitsol(SCIP *, SCIP_HEUR *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurExec(SCIP *, SCIP_HEUR *, SCIP_HEURTIMING, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolCopy(SCIP *, SCIP_PRESOL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolFree(SCIP *, SCIP_PRESOL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolInit(SCIP *, SCIP_PRESOL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolExit(SCIP *, SCIP_PRESOL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolInitpre(SCIP *, SCIP_PRESOL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolExitpre(SCIP *, SCIP_PRESOL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolExec(SCIP *, SCIP_PRESOL *, int, SCIP_PRESOLTIMING, int, int, int, int, int, int, int, int, int, int, int *, int *, int *, int *, int *, int *, int *, int *, int *, int *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerCopy(SCIP *, SCIP_PRICER *, SCIP_Bool *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerFree(SCIP *, SCIP_PRICER *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerInit(SCIP *, SCIP_PRICER *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerExit(SCIP *, SCIP_PRICER *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerInitsol(SCIP *, SCIP_PRICER *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerExitsol(SCIP *, SCIP_PRICER *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerRedcost(SCIP *, SCIP_PRICER *, SCIP_Real *, SCIP_Bool *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerFarkas(SCIP *, SCIP_PRICER *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropCopy(SCIP *, SCIP_PROP *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropFree(SCIP *, SCIP_PROP *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropInit(SCIP *, SCIP_PROP *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropExit(SCIP *, SCIP_PROP *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropInitpre(SCIP *, SCIP_PROP *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropExitpre(SCIP *, SCIP_PROP *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropInitsol(SCIP *, SCIP_PROP *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropExitsol(SCIP *, SCIP_PROP *, SCIP_Bool); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropPresol(SCIP *, SCIP_PROP *, int, SCIP_PRESOLTIMING, int, int, int, int, int, int, int, int, int, int, int *, int *, int *, int *, int *, int *, int *, int *, int *, int *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropExec(SCIP *, SCIP_PROP *, SCIP_PROPTIMING, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropResProp(SCIP *, SCIP_PROP *, SCIP_VAR *, int, SCIP_BOUNDTYPE, SCIP_BDCHGIDX *, SCIP_Real, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaCopy(SCIP *, SCIP_SEPA *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaFree(SCIP *, SCIP_SEPA *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaInit(SCIP *, SCIP_SEPA *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaExit(SCIP *, SCIP_SEPA *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaInitsol(SCIP *, SCIP_SEPA *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaExitsol(SCIP *, SCIP_SEPA *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaExeclp(SCIP *, SCIP_SEPA *, SCIP_RESULT *, unsigned int, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaExecsol(SCIP *, SCIP_SEPA *, SCIP_SOL *, SCIP_RESULT *, unsigned int, int); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyReaderCopy(SCIP *, SCIP_READER *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyReaderFree(SCIP *, SCIP_READER *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyReaderRead(SCIP *, SCIP_READER *, char const *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyReaderWrite(SCIP *, SCIP_READER *, FILE *, char const *, SCIP_PROBDATA *, SCIP_Bool, SCIP_OBJSENSE, SCIP_Real, SCIP_Real, SCIP_VAR **, int, int, int, int, int, SCIP_VAR **, int, int, SCIP_CONS **, int, int, int, SCIP_Bool, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxCopy(SCIP *, SCIP_RELAX *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxFree(SCIP *, SCIP_RELAX *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxInit(SCIP *, SCIP_RELAX *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxExit(SCIP *, SCIP_RELAX *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxInitsol(SCIP *, SCIP_RELAX *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxExitsol(SCIP *, SCIP_RELAX *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxExec(SCIP *, SCIP_RELAX *, SCIP_Real *, SCIP_RESULT *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselCopy(SCIP *, SCIP_NODESEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselFree(SCIP *, SCIP_NODESEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselInit(SCIP *, SCIP_NODESEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselExit(SCIP *, SCIP_NODESEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselInitsol(SCIP *, SCIP_NODESEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselExitsol(SCIP *, SCIP_NODESEL *); /*proto*/ +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselSelect(SCIP *, SCIP_NODESEL *, SCIP_NODE **); /*proto*/ +static int __pyx_f_9pyscipopt_4scip_PyNodeselComp(SCIP *, SCIP_NODESEL *, SCIP_NODE *, SCIP_NODE *); /*proto*/ +static void __pyx_f_9pyscipopt_4scip_relayMessage(SCIP_MESSAGEHDLR *, FILE *, char const *); /*proto*/ +static void __pyx_f_9pyscipopt_4scip_relayErrorMessage(void *, FILE *, char const *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Expr__set_state(struct __pyx_obj_9pyscipopt_4scip_Expr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_ExprCons__set_state(struct __pyx_obj_9pyscipopt_4scip_ExprCons *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_GenExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_GenExpr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_SumExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_SumExpr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_ProdExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_VarExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_VarExpr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PowExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_PowExpr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_UnaryExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Constant__set_state(struct __pyx_obj_9pyscipopt_4scip_Constant *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Benderscut__set_state(struct __pyx_obj_9pyscipopt_4scip_Benderscut *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Branchrule__set_state(struct __pyx_obj_9pyscipopt_4scip_Branchrule *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Conshdlr__set_state(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Cutsel__set_state(struct __pyx_obj_9pyscipopt_4scip_Cutsel *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Eventhdlr__set_state(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Heur__set_state(struct __pyx_obj_9pyscipopt_4scip_Heur *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Presol__set_state(struct __pyx_obj_9pyscipopt_4scip_Presol *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Pricer__set_state(struct __pyx_obj_9pyscipopt_4scip_Pricer *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Prop__set_state(struct __pyx_obj_9pyscipopt_4scip_Prop *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Sepa__set_state(struct __pyx_obj_9pyscipopt_4scip_Sepa *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Reader__set_state(struct __pyx_obj_9pyscipopt_4scip_Reader *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Relax__set_state(struct __pyx_obj_9pyscipopt_4scip_Relax *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Nodesel__set_state(struct __pyx_obj_9pyscipopt_4scip_Nodesel *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_RESULT__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_STATUS__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_STAGE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_NODETYPE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PROPTIMING__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_HEURTIMING__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *, PyObject *); /*proto*/ +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "pyscipopt.scip" +extern int __pyx_module_is_main_pyscipopt__scip; +int __pyx_module_is_main_pyscipopt__scip = 0; + +/* Implementation of "pyscipopt.scip" */ +/* #### Code section: global_var ### */ +static PyObject *__pyx_builtin_staticmethod; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_NotImplementedError; +static PyObject *__pyx_builtin_sorted; +static PyObject *__pyx_builtin_sum; +static PyObject *__pyx_builtin_AssertionError; +static PyObject *__pyx_builtin_StopIteration; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_max; +static PyObject *__pyx_builtin_ZeroDivisionError; +static PyObject *__pyx_builtin_map; +static PyObject *__pyx_builtin_Warning; +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_print; +static PyObject *__pyx_builtin_MemoryError; +static PyObject *__pyx_builtin_IOError; +static PyObject *__pyx_builtin_KeyError; +static PyObject *__pyx_builtin_LookupError; +static PyObject *__pyx_builtin_open; +static PyObject *__pyx_builtin_chr; +/* #### Code section: string_decls ### */ +static const char __pyx_k_B[] = "B"; +static const char __pyx_k_C[] = "C"; +static const char __pyx_k_I[] = "I"; +static const char __pyx_k_M[] = "M"; +static const char __pyx_k_c[] = "c"; +static const char __pyx_k_d[] = "d"; +static const char __pyx_k_e[] = "e"; +static const char __pyx_k_f[] = "f"; +static const char __pyx_k_i[] = "i"; +static const char __pyx_k_j[] = "j"; +static const char __pyx_k_n[] = "n"; +static const char __pyx_k_t[] = "t"; +static const char __pyx_k_v[] = "v"; +static const char __pyx_k_w[] = "w"; +static const char __pyx_k_x[] = "x"; +static const char __pyx_k_LP[] = "LP"; +static const char __pyx_k_Op[] = "Op"; +static const char __pyx_k__2[] = ", "; +static const char __pyx_k__6[] = ")"; +static const char __pyx_k__9[] = "("; +static const char __pyx_k_eq[] = "__eq__"; +static const char __pyx_k_fn[] = "fn"; +static const char __pyx_k_gc[] = "gc"; +static const char __pyx_k_lb[] = "lb"; +static const char __pyx_k_op[] = "op"; +static const char __pyx_k_os[] = "os"; +static const char __pyx_k_rc[] = "rc"; +static const char __pyx_k_ub[] = "ub"; +static const char __pyx_k_OFF[] = "OFF"; +static const char __pyx_k_Row[] = "Row"; +static const char __pyx_k__10[] = ","; +static const char __pyx_k__79[] = "{} {} {}"; +static const char __pyx_k__89[] = ""; +static const char __pyx_k__94[] = "_"; +static const char __pyx_k_abs[] = "abs"; +static const char __pyx_k_add[] = "__add__"; +static const char __pyx_k_beg[] = "beg"; +static const char __pyx_k_chr[] = "chr"; +static const char __pyx_k_cip[] = ".cip"; +static const char __pyx_k_col[] = "col"; +static const char __pyx_k_cos[] = "cos"; +static const char __pyx_k_cut[] = "cut"; +static const char __pyx_k_deg[] = "deg"; +static const char __pyx_k_des[] = "des"; +static const char __pyx_k_dis[] = "dis"; +static const char __pyx_k_div[] = "div"; +static const char __pyx_k_doc[] = "__doc__"; +static const char __pyx_k_exp[] = "exp"; +static const char __pyx_k_ext[] = "ext"; +static const char __pyx_k_get[] = "get"; +static const char __pyx_k_idx[] = "idx"; +static const char __pyx_k_inf[] = "inf"; +static const char __pyx_k_key[] = "key"; +static const char __pyx_k_lbs[] = "lbs"; +static const char __pyx_k_len[] = "__len__"; +static const char __pyx_k_lhs[] = "lhs"; +static const char __pyx_k_log[] = "log"; +static const char __pyx_k_lpi[] = "lpi"; +static const char __pyx_k_map[] = "map"; +static const char __pyx_k_max[] = "max"; +static const char __pyx_k_mul[] = "__mul__"; +static const char __pyx_k_nam[] = "nam"; +static const char __pyx_k_new[] = "__new__"; +static const char __pyx_k_obj[] = "obj"; +static const char __pyx_k_pos[] = "pos"; +static const char __pyx_k_ptr[] = "ptr"; +static const char __pyx_k_ray[] = "ray"; +static const char __pyx_k_rhs[] = "rhs"; +static const char __pyx_k_row[] = "row"; +static const char __pyx_k_sin[] = "sin"; +static const char __pyx_k_sol[] = "sol"; +static const char __pyx_k_sum[] = "sum"; +static const char __pyx_k_sys[] = "sys"; +static const char __pyx_k_tmp[] = "tmp"; +static const char __pyx_k_ubs[] = "ubs"; +static const char __pyx_k_val[] = "val"; +static const char __pyx_k_var[] = "var"; +static const char __pyx_k_AUTO[] = "AUTO"; +static const char __pyx_k_CONS[] = "CONS"; +static const char __pyx_k_Expr[] = "Expr"; +static const char __pyx_k_FAST[] = "FAST"; +static const char __pyx_k_FORK[] = "FORK"; +static const char __pyx_k_FREE[] = "FREE"; +static const char __pyx_k_Heur[] = "Heur"; +static const char __pyx_k_INIT[] = "INIT"; +static const char __pyx_k_LEAF[] = "LEAF"; +static const char __pyx_k_NONE[] = "NONE"; +static const char __pyx_k_Node[] = "Node"; +static const char __pyx_k_Prop[] = "Prop"; +static const char __pyx_k_SEPA[] = "SEPA"; +static const char __pyx_k_SYNC[] = "SYNC"; +static const char __pyx_k_Sepa[] = "Sepa"; +static const char __pyx_k_Term[] = "Term"; +static const char __pyx_k__114[] = "."; +static const char __pyx_k__126[] = "*"; +static const char __pyx_k__162[] = "+"; +static const char __pyx_k__163[] = "-"; +static const char __pyx_k__164[] = "/"; +static const char __pyx_k__165[] = "**"; +static const char __pyx_k__441[] = "<="; +static const char __pyx_k__442[] = ">="; +static const char __pyx_k_args[] = "args"; +static const char __pyx_k_attr[] = "attr"; +static const char __pyx_k_both[] = "both"; +static const char __pyx_k_c_lb[] = "c_lb"; +static const char __pyx_k_c_ub[] = "c_ub"; +static const char __pyx_k_coef[] = "coef"; +static const char __pyx_k_cols[] = "cols"; +static const char __pyx_k_cons[] = "cons"; +static const char __pyx_k_copy[] = "copy"; +static const char __pyx_k_cuts[] = "cuts"; +static const char __pyx_k_desc[] = "desc"; +static const char __pyx_k_dict[] = "__dict__"; +static const char __pyx_k_dual[] = "dual"; +static const char __pyx_k_elem[] = "elem"; +static const char __pyx_k_exit[] = "__exit__"; +static const char __pyx_k_expo[] = "expo"; +static const char __pyx_k_expr[] = "expr"; +static const char __pyx_k_fabs[] = "fabs"; +static const char __pyx_k_file[] = "file"; +static const char __pyx_k_frac[] = "frac"; +static const char __pyx_k_free[] = "free"; +static const char __pyx_k_freq[] = "freq"; +static const char __pyx_k_hash[] = "__hash__"; +static const char __pyx_k_heur[] = "heur"; +static const char __pyx_k_idxs[] = "idxs"; +static const char __pyx_k_inds[] = "inds"; +static const char __pyx_k_init[] = "__init__"; +static const char __pyx_k_isEQ[] = "isEQ"; +static const char __pyx_k_isGE[] = "isGE"; +static const char __pyx_k_isGT[] = "isGT"; +static const char __pyx_k_isLE[] = "isLE"; +static const char __pyx_k_isLT[] = "isLT"; +static const char __pyx_k_keys[] = "keys"; +static const char __pyx_k_lhss[] = "lhss"; +static const char __pyx_k_main[] = "__main__"; +static const char __pyx_k_name[] = "name"; +static const char __pyx_k_node[] = "node"; +static const char __pyx_k_objs[] = "objs"; +static const char __pyx_k_op_2[] = "_op"; +static const char __pyx_k_open[] = "open"; +static const char __pyx_k_path[] = "path"; +static const char __pyx_k_plus[] = "plus"; +static const char __pyx_k_prod[] = "prod"; +static const char __pyx_k_prop[] = "prop"; +static const char __pyx_k_repr[] = "__repr__"; +static const char __pyx_k_rhss[] = "rhss"; +static const char __pyx_k_root[] = "root"; +static const char __pyx_k_row1[] = "row1"; +static const char __pyx_k_row2[] = "row2"; +static const char __pyx_k_rows[] = "rows"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_send[] = "send"; +static const char __pyx_k_sepa[] = "sepa"; +static const char __pyx_k_side[] = "side"; +static const char __pyx_k_sols[] = "_sols"; +static const char __pyx_k_spec[] = "__spec__"; +static const char __pyx_k_sqrt[] = "sqrt"; +static const char __pyx_k_stat[] = "stat"; +static const char __pyx_k_term[] = "term"; +static const char __pyx_k_test[] = "__test__"; +static const char __pyx_k_true[] = "true"; +static const char __pyx_k_tvar[] = "_tvar"; +static const char __pyx_k_val1[] = "val1"; +static const char __pyx_k_val2[] = "val2"; +static const char __pyx_k_vals[] = "vals"; +static const char __pyx_k_var1[] = "var1"; +static const char __pyx_k_var2[] = "var2"; +static const char __pyx_k_vars[] = "vars"; +static const char __pyx_k_warn[] = "warn"; +static const char __pyx_k_zero[] = "zero"; +static const char __pyx_k_CHECK[] = "CHECK"; +static const char __pyx_k_CHILD[] = "CHILD"; +static const char __pyx_k_CONST[] = "CONST"; +static const char __pyx_k_ERROR[] = "ERROR"; +static const char __pyx_k_Event[] = "Event"; +static const char __pyx_k_FIXED[] = "FIXED"; +static const char __pyx_k_LP_lp[] = "LP.lp"; +static const char __pyx_k_MAJOR[] = "MAJOR"; +static const char __pyx_k_MINOR[] = "MINOR"; +static const char __pyx_k_Model[] = "Model"; +static const char __pyx_k_NLRow[] = "NLRow"; +static const char __pyx_k_PATCH[] = "PATCH"; +static const char __pyx_k_PyRow[] = "PyRow"; +static const char __pyx_k_RELAX[] = "RELAX"; +static const char __pyx_k_REOPT[] = "REOPT"; +static const char __pyx_k_Relax[] = "Relax"; +static const char __pyx_k_Union[] = "Union"; +static const char __pyx_k__1188[] = "?"; +static const char __pyx_k_add_2[] = "add"; +static const char __pyx_k_basic[] = "basic"; +static const char __pyx_k_binds[] = "binds"; +static const char __pyx_k_c_beg[] = "c_beg"; +static const char __pyx_k_c_col[] = "c_col"; +static const char __pyx_k_c_lbs[] = "c_lbs"; +static const char __pyx_k_c_lhs[] = "c_lhs"; +static const char __pyx_k_c_obj[] = "c_obj"; +static const char __pyx_k_c_ray[] = "c_ray"; +static const char __pyx_k_c_rhs[] = "c_rhs"; +static const char __pyx_k_c_row[] = "c_row"; +static const char __pyx_k_c_ubs[] = "c_ubs"; +static const char __pyx_k_cfile[] = "cfile"; +static const char __pyx_k_check[] = "check"; +static const char __pyx_k_child[] = "child"; +static const char __pyx_k_class[] = "__class__"; +static const char __pyx_k_clear[] = "clear"; +static const char __pyx_k_close[] = "close"; +static const char __pyx_k_cname[] = "cname"; +static const char __pyx_k_coeff[] = "coeff"; +static const char __pyx_k_coefs[] = "coefs"; +static const char __pyx_k_conss[] = "conss"; +static const char __pyx_k_const[] = "const"; +static const char __pyx_k_count[] = "count"; +static const char __pyx_k_cutlp[] = "cutlp"; +static const char __pyx_k_delay[] = "delay"; +static const char __pyx_k_enter[] = "__enter__"; +static const char __pyx_k_entry[] = "entry"; +static const char __pyx_k_error[] = "error"; +static const char __pyx_k_event[] = "event"; +static const char __pyx_k_exact[] = "exact"; +static const char __pyx_k_fixed[] = "fixed"; +static const char __pyx_k_force[] = "force"; +static const char __pyx_k_getLb[] = "getLb"; +static const char __pyx_k_getOp[] = "getOp"; +static const char __pyx_k_getUb[] = "getUb"; +static const char __pyx_k_items[] = "items"; +static const char __pyx_k_iters[] = "iters"; +static const char __pyx_k_itlim[] = "itlim"; +static const char __pyx_k_lhs_2[] = "_lhs"; +static const char __pyx_k_local[] = "local"; +static const char __pyx_k_lower[] = "lower"; +static const char __pyx_k_minus[] = "minus"; +static const char __pyx_k_model[] = "model"; +static const char __pyx_k_mul_2[] = "mul"; +static const char __pyx_k_ncols[] = "ncols"; +static const char __pyx_k_nlrow[] = "nlrow"; +static const char __pyx_k_nnonz[] = "nnonz"; +static const char __pyx_k_node1[] = "node1"; +static const char __pyx_k_node2[] = "node2"; +static const char __pyx_k_nodes[] = "nodes"; +static const char __pyx_k_nprop[] = "nprop"; +static const char __pyx_k_nrows[] = "nrows"; +static const char __pyx_k_nsols[] = "nsols"; +static const char __pyx_k_nvars[] = "nvars"; +static const char __pyx_k_opidx[] = "opidx"; +static const char __pyx_k_other[] = "other"; +static const char __pyx_k_param[] = "param"; +static const char __pyx_k_power[] = "power"; +static const char __pyx_k_print[] = "print"; +static const char __pyx_k_proxy[] = "proxy"; +static const char __pyx_k_pyVar[] = "pyVar"; +static const char __pyx_k_pyvar[] = "pyvar"; +static const char __pyx_k_quiet[] = "quiet"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_relax[] = "relax"; +static const char __pyx_k_rhs_2[] = "_rhs"; +static const char __pyx_k_sense[] = "sense"; +static const char __pyx_k_slots[] = "__slots__"; +static const char __pyx_k_sol_2[] = "_sol"; +static const char __pyx_k_solve[] = "solve"; +static const char __pyx_k_state[] = "state"; +static const char __pyx_k_super[] = "super"; +static const char __pyx_k_terms[] = "terms"; +static const char __pyx_k_throw[] = "throw"; +static const char __pyx_k_trans[] = "trans"; +static const char __pyx_k_upper[] = "upper"; +static const char __pyx_k_utf_8[] = "utf-8"; +static const char __pyx_k_valid[] = "valid"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_var_2[] = "_var"; +static const char __pyx_k_vtype[] = "vtype"; +static const char __pyx_k_write[] = "write"; +static const char __pyx_k_BINARY[] = "BINARY"; +static const char __pyx_k_CUTOFF[] = "CUTOFF"; +static const char __pyx_k_Column[] = "Column"; +static const char __pyx_k_Cutsel[] = "Cutsel"; +static const char __pyx_k_Expr_s[] = "Expr(%s)"; +static const char __pyx_k_HARDLP[] = "HARDLP"; +static const char __pyx_k_MEDIUM[] = "MEDIUM"; +static const char __pyx_k_ORcons[] = "ORcons"; +static const char __pyx_k_PSEUDO[] = "PSEUDO"; +static const char __pyx_k_Presol[] = "Presol"; +static const char __pyx_k_Pricer[] = "Pricer"; +static const char __pyx_k_PyCons[] = "PyCons"; +static const char __pyx_k_Reader[] = "Reader"; +static const char __pyx_k_SOLVED[] = "SOLVED"; +static const char __pyx_k_Term_s[] = "Term(%s)"; +static const char __pyx_k_UNSPEC[] = "UNSPEC"; +static const char __pyx_k_addCol[] = "addCol"; +static const char __pyx_k_addCut[] = "addCut"; +static const char __pyx_k_addRow[] = "addRow"; +static const char __pyx_k_addSol[] = "addSol"; +static const char __pyx_k_addVar[] = "addVar"; +static const char __pyx_k_append[] = "append"; +static const char __pyx_k_auxvar[] = "_auxvar"; +static const char __pyx_k_bdtype[] = "bdtype"; +static const char __pyx_k_binVar[] = "_binVar"; +static const char __pyx_k_binvar[] = "binvar"; +static const char __pyx_k_c_inds[] = "c_inds"; +static const char __pyx_k_c_lhss[] = "c_lhss"; +static const char __pyx_k_c_objs[] = "c_objs"; +static const char __pyx_k_c_path[] = "c_path"; +static const char __pyx_k_c_rhss[] = "c_rhss"; +static const char __pyx_k_chgLhs[] = "chgLhs"; +static const char __pyx_k_chgObj[] = "chgObj"; +static const char __pyx_k_chgRhs[] = "chgRhs"; +static const char __pyx_k_coeffs[] = "coeffs"; +static const char __pyx_k_cutoff[] = "cutoff"; +static const char __pyx_k_cutsel[] = "cutsel"; +static const char __pyx_k_degree[] = "degree"; +static const char __pyx_k_delVar[] = "delVar"; +static const char __pyx_k_dict_2[] = "_dict"; +static const char __pyx_k_domchg[] = "domchg"; +static const char __pyx_k_enable[] = "enable"; +static const char __pyx_k_extend[] = "extend"; +static const char __pyx_k_failed[] = " failed!"; +static const char __pyx_k_fdopen[] = "fdopen"; +static const char __pyx_k_fileno[] = "fileno"; +static const char __pyx_k_fixVar[] = "fixVar"; +static const char __pyx_k_format[] = "format"; +static const char __pyx_k_getCol[] = "getCol"; +static const char __pyx_k_getGap[] = "getGap"; +static const char __pyx_k_getLhs[] = "getLhs"; +static const char __pyx_k_getObj[] = "getObj"; +static const char __pyx_k_getRhs[] = "getRhs"; +static const char __pyx_k_getRow[] = "getRow"; +static const char __pyx_k_getVal[] = "getVal"; +static const char __pyx_k_getVar[] = "getVar"; +static const char __pyx_k_heur_2[] = "_heur"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_indvar[] = "indvar"; +static const char __pyx_k_isInLP[] = "isInLP"; +static const char __pyx_k_isZero[] = "isZero"; +static const char __pyx_k_isdict[] = "isdict"; +static const char __pyx_k_kwargs[] = "kwargs"; +static const char __pyx_k_lambda[] = ""; +static const char __pyx_k_leaves[] = "_leaves"; +static const char __pyx_k_length[] = "length"; +static const char __pyx_k_linear[] = "linear"; +static const char __pyx_k_locale[] = "locale"; +static const char __pyx_k_merged[] = "merged"; +static const char __pyx_k_method[] = "method"; +static const char __pyx_k_module[] = "__module__"; +static const char __pyx_k_name_2[] = "__name__"; +static const char __pyx_k_ncands[] = "ncands"; +static const char __pyx_k_nconss[] = "nconss"; +static const char __pyx_k_negate[] = "negate"; +static const char __pyx_k_newEnf[] = "newEnf"; +static const char __pyx_k_newRem[] = "newRem"; +static const char __pyx_k_newlhs[] = "newlhs"; +static const char __pyx_k_newobj[] = "newobj"; +static const char __pyx_k_newrhs[] = "newrhs"; +static const char __pyx_k_newval[] = "newval"; +static const char __pyx_k_niters[] = "niters"; +static const char __pyx_k_nlrows[] = "nlrows"; +static const char __pyx_k_number[] = "number"; +static const char __pyx_k_objval[] = "objval"; +static const char __pyx_k_offset[] = "offset"; +static const char __pyx_k_params[] = "params"; +static const char __pyx_k_pickle[] = "pickle"; +static const char __pyx_k_presol[] = "presol"; +static const char __pyx_k_pricer[] = "pricer"; +static const char __pyx_k_pyCons[] = "pyCons"; +static const char __pyx_k_pycons[] = "pycons"; +static const char __pyx_k_readLP[] = "readLP"; +static const char __pyx_k_reader[] = "reader"; +static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_repeat[] = "repeat"; +static const char __pyx_k_resVar[] = "_resVar"; +static const char __pyx_k_result[] = "result"; +static const char __pyx_k_resvar[] = "resvar"; +static const char __pyx_k_rhsvar[] = "rhsvar"; +static const char __pyx_k_solptr[] = "solptr"; +static const char __pyx_k_sols_2[] = "sols"; +static const char __pyx_k_sorted[] = "sorted"; +static const char __pyx_k_stderr[] = "stderr"; +static const char __pyx_k_stdout[] = "stdout"; +static const char __pyx_k_stored[] = "stored"; +static const char __pyx_k_timing[] = "timing"; +static const char __pyx_k_to_ptr[] = "to_ptr"; +static const char __pyx_k_trySol[] = "trySol"; +static const char __pyx_k_typing[] = "typing"; +static const char __pyx_k_update[] = "update"; +static const char __pyx_k_vals_2[] = "_vals"; +static const char __pyx_k_values[] = "values"; +static const char __pyx_k_varidx[] = "varidx"; +static const char __pyx_k_varpos[] = "varpos"; +static const char __pyx_k_vars_2[] = "_vars"; +static const char __pyx_k_weight[] = "weight"; +static const char __pyx_k_ANDcons[] = "ANDcons"; +static const char __pyx_k_Benders[] = "Benders"; +static const char __pyx_k_COUNTER[] = "COUNTER"; +static const char __pyx_k_DEADEND[] = "DEADEND"; +static const char __pyx_k_DEFAULT[] = "DEFAULT"; +static const char __pyx_k_DELAYED[] = "DELAYED"; +static const char __pyx_k_EASYCIP[] = "EASYCIP"; +static const char __pyx_k_GenExpr[] = "GenExpr"; +static const char __pyx_k_IMPLINT[] = "IMPLINT"; +static const char __pyx_k_INTEGER[] = "INTEGER"; +static const char __pyx_k_IOError[] = "IOError"; +static const char __pyx_k_LPEVENT[] = "LPEVENT"; +static const char __pyx_k_Nodesel[] = "Nodesel"; +static const char __pyx_k_OPTIMAL[] = "OPTIMAL"; +static const char __pyx_k_PROBLEM[] = "PROBLEM"; +static const char __pyx_k_PowExpr[] = "PowExpr"; +static const char __pyx_k_SIBLING[] = "SIBLING"; +static const char __pyx_k_SOLVELP[] = "SOLVELP"; +static const char __pyx_k_SOLVING[] = "SOLVING"; +static const char __pyx_k_SUBROOT[] = "SUBROOT"; +static const char __pyx_k_SUCCESS[] = "SUCCESS"; +static const char __pyx_k_SumExpr[] = "SumExpr"; +static const char __pyx_k_UNKNOWN[] = "UNKNOWN"; +static const char __pyx_k_UPWARDS[] = "UPWARDS"; +static const char __pyx_k_VarExpr[] = "VarExpr"; +static const char __pyx_k_Warning[] = "Warning"; +static const char __pyx_k_XORcons[] = "XORcons"; +static const char __pyx_k_absfile[] = "absfile"; +static const char __pyx_k_abspath[] = "abspath"; +static const char __pyx_k_addCols[] = "addCols"; +static const char __pyx_k_addCons[] = "addCons"; +static const char __pyx_k_addRows[] = "addRows"; +static const char __pyx_k_auxviol[] = "auxviol"; +static const char __pyx_k_benders[] = "benders"; +static const char __pyx_k_binvars[] = "binvars"; +static const char __pyx_k_bounded[] = "_bounded"; +static const char __pyx_k_c_binds[] = "c_binds"; +static const char __pyx_k_c_coefs[] = "c_coefs"; +static const char __pyx_k_capsule[] = "capsule"; +static const char __pyx_k_cardval[] = "cardval"; +static const char __pyx_k_chgCoef[] = "chgCoef"; +static const char __pyx_k_chgSide[] = "chgSide"; +static const char __pyx_k_closefd[] = "closefd"; +static const char __pyx_k_confvar[] = "confvar"; +static const char __pyx_k_conss_2[] = "_conss"; +static const char __pyx_k_delCols[] = "delCols"; +static const char __pyx_k_delCons[] = "delCons"; +static const char __pyx_k_delRows[] = "delRows"; +static const char __pyx_k_delayed[] = "delayed"; +static const char __pyx_k_deleted[] = "deleted"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_dualsol[] = "dualsol"; +static const char __pyx_k_dynamic[] = "dynamic"; +static const char __pyx_k_endDive[] = "endDive"; +static const char __pyx_k_enforce[] = "enforce"; +static const char __pyx_k_entries[] = "entries"; +static const char __pyx_k_epsilon[] = "epsilon"; +static const char __pyx_k_eqchild[] = "eqchild"; +static const char __pyx_k_feastol[] = "feastol"; +static const char __pyx_k_freeSol[] = "freeSol"; +static const char __pyx_k_freqofs[] = "freqofs"; +static const char __pyx_k_genexpr[] = "genexpr"; +static const char __pyx_k_getCols[] = "getCols"; +static const char __pyx_k_getDual[] = "getDual"; +static const char __pyx_k_getNLPs[] = "getNLPs"; +static const char __pyx_k_getName[] = "getName"; +static const char __pyx_k_getNode[] = "getNode"; +static const char __pyx_k_getNorm[] = "getNorm"; +static const char __pyx_k_getSols[] = "getSols"; +static const char __pyx_k_getType[] = "getType"; +static const char __pyx_k_getVals[] = "getVals"; +static const char __pyx_k_getVars[] = "getVars"; +static const char __pyx_k_getitem[] = "__getitem__"; +static const char __pyx_k_hashval[] = "hashval"; +static const char __pyx_k_indices[] = "indices"; +static const char __pyx_k_indvars[] = "indvars"; +static const char __pyx_k_initial[] = "initial"; +static const char __pyx_k_intvars[] = "intvars"; +static const char __pyx_k_isLocal[] = "isLocal"; +static const char __pyx_k_islpcut[] = "islpcut"; +static const char __pyx_k_lastcol[] = "lastcol"; +static const char __pyx_k_lastrow[] = "lastrow"; +static const char __pyx_k_lincoef[] = "lincoef"; +static const char __pyx_k_lincons[] = "lincons"; +static const char __pyx_k_linvars[] = "linvars"; +static const char __pyx_k_lpcands[] = "lpcands"; +static const char __pyx_k_lperror[] = "lperror"; +static const char __pyx_k_n_conss[] = "n_conss"; +static const char __pyx_k_nchgbds[] = "nchgbds"; +static const char __pyx_k_newInit[] = "newInit"; +static const char __pyx_k_nleaves[] = "_nleaves"; +static const char __pyx_k_nodesel[] = "nodesel"; +static const char __pyx_k_nrounds[] = "nrounds"; +static const char __pyx_k_nvars_2[] = "_nvars"; +static const char __pyx_k_optimal[] = "optimal"; +static const char __pyx_k_os_path[] = "os.path"; +static const char __pyx_k_partial[] = "partial"; +static const char __pyx_k_prepare[] = "__prepare__"; +static const char __pyx_k_quality[] = "quality"; +static const char __pyx_k_readSol[] = "readSol"; +static const char __pyx_k_redcost[] = "redcost"; +static const char __pyx_k_restart[] = "restart"; +static const char __pyx_k_retcode[] = "retcode"; +static const char __pyx_k_selnode[] = "selnode"; +static const char __pyx_k_setting[] = "setting"; +static const char __pyx_k_sqrcoef[] = "sqrcoef"; +static const char __pyx_k_sqrexpr[] = "sqrexpr"; +static const char __pyx_k_subprob[] = "subprob"; +static const char __pyx_k_success[] = "success"; +static const char __pyx_k_sumexpr[] = "sumexpr"; +static const char __pyx_k_termidx[] = "termidx"; +static const char __pyx_k_truediv[] = "__truediv__"; +static const char __pyx_k_unknown[] = "unknown"; +static const char __pyx_k_upchild[] = "upchild"; +static const char __pyx_k_varexpr[] = "varexpr"; +static const char __pyx_k_vartype[] = "vartype"; +static const char __pyx_k_verbose[] = "verbose"; +static const char __pyx_k_version[] = "version"; +static const char __pyx_k_weakref[] = "weakref"; +static const char __pyx_k_weights[] = "weights"; +static const char __pyx_k_writeLP[] = "writeLP"; +static const char __pyx_k_BEFORELP[] = "BEFORELP"; +static const char __pyx_k_BRANCHED[] = "BRANCHED"; +static const char __pyx_k_CPSOLVER[] = "CPSOLVER"; +static const char __pyx_k_Conshdlr[] = "Conshdlr"; +static const char __pyx_k_Constant[] = "Constant"; +static const char __pyx_k_DISABLED[] = "DISABLED"; +static const char __pyx_k_ExprCons[] = "ExprCons("; +static const char __pyx_k_FEASIBLE[] = "FEASIBLE"; +static const char __pyx_k_FOUNDSOL[] = "FOUNDSOL"; +static const char __pyx_k_GAPLIMIT[] = "GAPLIMIT"; +static const char __pyx_k_Iterable[] = "Iterable"; +static const char __pyx_k_JUNCTION[] = "JUNCTION"; +static const char __pyx_k_KeyError[] = "KeyError"; +static const char __pyx_k_LPSOLVED[] = "LPSOLVED"; +static const char __pyx_k_LP_clear[] = "LP.clear"; +static const char __pyx_k_LP_ncols[] = "LP.ncols"; +static const char __pyx_k_LP_nrows[] = "LP.nrows"; +static const char __pyx_k_LP_solve[] = "LP.solve"; +static const char __pyx_k_MEMLIMIT[] = "MEMLIMIT"; +static const char __pyx_k_NEWROUND[] = "NEWROUND"; +static const char __pyx_k_NUMERICS[] = "NUMERICS"; +static const char __pyx_k_OBJLIMIT[] = "OBJLIMIT"; +static const char __pyx_k_Operator[] = "Operator"; +static const char __pyx_k_ProdExpr[] = "ProdExpr"; +static const char __pyx_k_ROWEVENT[] = "ROWEVENT"; +static const char __pyx_k_SOLEVENT[] = "SOLEVENT"; +static const char __pyx_k_SOLFOUND[] = "SOLFOUND"; +static const char __pyx_k_SOLLIMIT[] = "SOLLIMIT"; +static const char __pyx_k_SOS1cons[] = "SOS1cons"; +static const char __pyx_k_SOS2cons[] = "SOS2cons"; +static const char __pyx_k_Solution[] = "Solution"; +static const char __pyx_k_VARADDED[] = "VARADDED"; +static const char __pyx_k_VAREVENT[] = "VAREVENT"; +static const char __pyx_k_VARFIXED[] = "VARFIXED"; +static const char __pyx_k_Variable[] = "Variable"; +static const char __pyx_k_activity[] = "activity"; +static const char __pyx_k_addConss[] = "addConss"; +static const char __pyx_k_auxvar_2[] = "auxvar"; +static const char __pyx_k_category[] = "category"; +static const char __pyx_k_checkSol[] = "checkSol"; +static const char __pyx_k_checkint[] = "checkint"; +static const char __pyx_k_chgBound[] = "chgBound"; +static const char __pyx_k_chgVarLb[] = "chgVarLb"; +static const char __pyx_k_chgVarUb[] = "chgVarUb"; +static const char __pyx_k_children[] = "children"; +static const char __pyx_k_coeffs_2[] = "_coeffs"; +static const char __pyx_k_comments[] = "comments"; +static const char __pyx_k_conscopy[] = "conscopy"; +static const char __pyx_k_consexit[] = "consexit"; +static const char __pyx_k_consfree[] = "consfree"; +static const char __pyx_k_conshdlr[] = "conshdlr"; +static const char __pyx_k_consinit[] = "consinit"; +static const char __pyx_k_conslock[] = "conslock"; +static const char __pyx_k_consprop[] = "consprop"; +static const char __pyx_k_constant[] = "constant"; +static const char __pyx_k_constype[] = "constype"; +static const char __pyx_k_consvars[] = "consvars"; +static const char __pyx_k_contvars[] = "contvars"; +static const char __pyx_k_cutrelax[] = "cutrelax"; +static const char __pyx_k_dispchar[] = "dispchar"; +static const char __pyx_k_enfotype[] = "enfotype"; +static const char __pyx_k_estimate[] = "estimate"; +static const char __pyx_k_evaluate[] = "_evaluate"; +static const char __pyx_k_exponent[] = "exponent"; +static const char __pyx_k_feasFrac[] = "feasFrac"; +static const char __pyx_k_feasible[] = "feasible"; +static const char __pyx_k_filename[] = "filename"; +static const char __pyx_k_firstcol[] = "firstcol"; +static const char __pyx_k_firstrow[] = "firstrow"; +static const char __pyx_k_fixedval[] = "fixedval"; +static const char __pyx_k_forcecut[] = "forcecut"; +static const char __pyx_k_freeProb[] = "freeProb"; +static const char __pyx_k_freescip[] = "_freescip"; +static const char __pyx_k_from_ptr[] = "from_ptr"; +static const char __pyx_k_gaplimit[] = "gaplimit"; +static const char __pyx_k_getConss[] = "getConss"; +static const char __pyx_k_getDepth[] = "getDepth"; +static const char __pyx_k_getIndex[] = "getIndex"; +static const char __pyx_k_getLPPos[] = "getLPPos"; +static const char __pyx_k_getLPSol[] = "getLPSol"; +static const char __pyx_k_getNCuts[] = "getNCuts"; +static const char __pyx_k_getNNonz[] = "getNNonz"; +static const char __pyx_k_getNSols[] = "getNSols"; +static const char __pyx_k_getNVars[] = "getNVars"; +static const char __pyx_k_getParam[] = "getParam"; +static const char __pyx_k_getSides[] = "getSides"; +static const char __pyx_k_getSlack[] = "getSlack"; +static const char __pyx_k_getStage[] = "getStage"; +static const char __pyx_k_getstate[] = "__getstate__"; +static const char __pyx_k_heurexec[] = "heurexec"; +static const char __pyx_k_heurexit[] = "heurexit"; +static const char __pyx_k_heurfree[] = "heurfree"; +static const char __pyx_k_heurinit[] = "heurinit"; +static const char __pyx_k_implvars[] = "implvars"; +static const char __pyx_k_infinity[] = "infinity"; +static const char __pyx_k_isActive[] = "isActive"; +static const char __pyx_k_isFeasEQ[] = "isFeasEQ"; +static const char __pyx_k_isLinear[] = "isLinear"; +static const char __pyx_k_isconvex[] = "isconvex"; +static const char __pyx_k_leaves_2[] = "leaves"; +static const char __pyx_k_lhsslack[] = "lhsslack"; +static const char __pyx_k_lincoefs[] = "lincoefs"; +static const char __pyx_k_linexprs[] = "_linexprs"; +static const char __pyx_k_linterms[] = "linterms"; +static const char __pyx_k_locktype[] = "locktype"; +static const char __pyx_k_maxdepth[] = "maxdepth"; +static const char __pyx_k_maximize[] = "maximize"; +static const char __pyx_k_memlimit[] = "memlimit"; +static const char __pyx_k_minimize[] = "minimize"; +static const char __pyx_k_nbenders[] = "nbenders"; +static const char __pyx_k_nconss_2[] = "_nconss"; +static const char __pyx_k_newCheck[] = "newCheck"; +static const char __pyx_k_newbound[] = "newbound"; +static const char __pyx_k_nlinvars[] = "nlinvars"; +static const char __pyx_k_nlocksup[] = "nlocksup"; +static const char __pyx_k_nlpcands[] = "nlpcands"; +static const char __pyx_k_nodecomp[] = "nodecomp"; +static const char __pyx_k_nodeexit[] = "nodeexit"; +static const char __pyx_k_nodefree[] = "nodefree"; +static const char __pyx_k_nodeinit[] = "nodeinit"; +static const char __pyx_k_objlimit[] = "objlimit"; +static const char __pyx_k_objscale[] = "objscale"; +static const char __pyx_k_objsense[] = "objsense"; +static const char __pyx_k_onlyroot[] = "onlyroot"; +static const char __pyx_k_optimize[] = "optimize"; +static const char __pyx_k_origcopy[] = "origcopy"; +static const char __pyx_k_original[] = "original"; +static const char __pyx_k_presolve[] = "presolve"; +static const char __pyx_k_printRow[] = "printRow"; +static const char __pyx_k_printSol[] = "printSol"; +static const char __pyx_k_priority[] = "priority"; +static const char __pyx_k_prodexpr[] = "prodexpr"; +static const char __pyx_k_propexec[] = "propexec"; +static const char __pyx_k_propexit[] = "propexit"; +static const char __pyx_k_propfree[] = "propfree"; +static const char __pyx_k_propfreq[] = "propfreq"; +static const char __pyx_k_propinit[] = "propinit"; +static const char __pyx_k_ptrtuple[] = "ptrtuple"; +static const char __pyx_k_pyx_type[] = "__pyx_type"; +static const char __pyx_k_quadcons[] = "quadcons"; +static const char __pyx_k_qualname[] = "__qualname__"; +static const char __pyx_k_quicksum[] = "quicksum"; +static const char __pyx_k_rhsslack[] = "rhsslack"; +static const char __pyx_k_scip_col[] = "scip_col"; +static const char __pyx_k_scip_con[] = "scip_con"; +static const char __pyx_k_scip_sol[] = "scip_sol"; +static const char __pyx_k_scip_var[] = "scip_var"; +static const char __pyx_k_scipvar1[] = "scipvar1"; +static const char __pyx_k_scipvar2[] = "scipvar2"; +static const char __pyx_k_sepaexit[] = "sepaexit"; +static const char __pyx_k_sepafree[] = "sepafree"; +static const char __pyx_k_sepafreq[] = "sepafreq"; +static const char __pyx_k_sepainit[] = "sepainit"; +static const char __pyx_k_separate[] = "separate"; +static const char __pyx_k_setCheck[] = "setCheck"; +static const char __pyx_k_setParam[] = "setParam"; +static const char __pyx_k_set_name[] = "__set_name__"; +static const char __pyx_k_setstate[] = "__setstate__"; +static const char __pyx_k_shareaux[] = "shareaux"; +static const char __pyx_k_siblings[] = "_siblings"; +static const char __pyx_k_sollimit[] = "sollimit"; +static const char __pyx_k_solution[] = "solution"; +static const char __pyx_k_solvecip[] = "solvecip"; +static const char __pyx_k_splitext[] = "splitext"; +static const char __pyx_k_subprobs[] = "subprobs"; +static const char __pyx_k_termlist[] = "termlist"; +static const char __pyx_k_termvars[] = "termvars"; +static const char __pyx_k_valsdict[] = "valsdict"; +static const char __pyx_k_var_dict[] = "var_dict"; +static const char __pyx_k_varexprs[] = "varexprs"; +static const char __pyx_k_variable[] = "variable"; +static const char __pyx_k_varindex[] = "varindex"; +static const char __pyx_k_vartuple[] = "vartuple"; +static const char __pyx_k_warnings[] = "warnings"; +static const char __pyx_k_writeSol[] = "writeSol"; +static const char __pyx_k_BENCHMARK[] = "BENCHMARK"; +static const char __pyx_k_CONSADDED[] = "CONSADDED"; +static const char __pyx_k_DIDNOTRUN[] = "DIDNOTRUN"; +static const char __pyx_k_DOWNWARDS[] = "DOWNWARDS"; +static const char __pyx_k_DUALLIMIT[] = "DUALLIMIT"; +static const char __pyx_k_EXITSOLVE[] = "EXITSOLVE"; +static const char __pyx_k_Eventhdlr[] = "Eventhdlr"; +static const char __pyx_k_FOCUSNODE[] = "FOCUSNODE"; +static const char __pyx_k_FREETRANS[] = "FREETRANS"; +static const char __pyx_k_IMPLADDED[] = "IMPLADDED"; +static const char __pyx_k_INFORUNBD[] = "INFORUNBD"; +static const char __pyx_k_INITSOLVE[] = "INITSOLVE"; +static const char __pyx_k_ITERLIMIT[] = "ITERLIMIT"; +static const char __pyx_k_LBCHANGED[] = "LBCHANGED"; +static const char __pyx_k_LBRELAXED[] = "LBRELAXED"; +static const char __pyx_k_LP_addCol[] = "LP.addCol"; +static const char __pyx_k_LP_addRow[] = "LP.addRow"; +static const char __pyx_k_LP_chgObj[] = "LP.chgObj"; +static const char __pyx_k_LP_readLP[] = "LP.readLP"; +static const char __pyx_k_NODEEVENT[] = "NODEEVENT"; +static const char __pyx_k_NODELIMIT[] = "NODELIMIT"; +static const char __pyx_k_NOTSOLVED[] = "NOTSOLVED"; +static const char __pyx_k_PHASEFEAS[] = "PHASEFEAS"; +static const char __pyx_k_PRESOLVED[] = "PRESOLVED"; +static const char __pyx_k_SEPARATED[] = "SEPARATED"; +static const char __pyx_k_SUSPENDED[] = "SUSPENDED"; +static const char __pyx_k_TIMELIMIT[] = "TIMELIMIT"; +static const char __pyx_k_Term___eq[] = "Term.__eq__"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_UBCHANGED[] = "UBCHANGED"; +static const char __pyx_k_UBRELAXED[] = "UBRELAXED"; +static const char __pyx_k_UNBOUNDED[] = "UNBOUNDED"; +static const char __pyx_k_UnaryExpr[] = "UnaryExpr"; +static const char __pyx_k_activeone[] = "activeone"; +static const char __pyx_k_addConsOr[] = "addConsOr"; +static const char __pyx_k_addPyCons[] = "addPyCons"; +static const char __pyx_k_benders_2[] = "_benders"; +static const char __pyx_k_bilincoef[] = "bilincoef"; +static const char __pyx_k_branchVar[] = "branchVar"; +static const char __pyx_k_branchdir[] = "branchdir"; +static const char __pyx_k_c_dualsol[] = "c_dualsol"; +static const char __pyx_k_c_redcost[] = "c_redcost"; +static const char __pyx_k_checktype[] = "checktype"; +static const char __pyx_k_conscheck[] = "conscheck"; +static const char __pyx_k_consparse[] = "consparse"; +static const char __pyx_k_consprint[] = "consprint"; +static const char __pyx_k_constrans[] = "constrans"; +static const char __pyx_k_createSol[] = "createSol"; +static const char __pyx_k_cutpseudo[] = "cutpseudo"; +static const char __pyx_k_delayprop[] = "delayprop"; +static const char __pyx_k_delaysepa[] = "delaysepa"; +static const char __pyx_k_disj_cons[] = "disj_cons"; +static const char __pyx_k_downchild[] = "downchild"; +static const char __pyx_k_dropEvent[] = "dropEvent"; +static const char __pyx_k_duallimit[] = "duallimit"; +static const char __pyx_k_dualsol_2[] = "_dualsol"; +static const char __pyx_k_eagerfreq[] = "eagerfreq"; +static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_eventcopy[] = "eventcopy"; +static const char __pyx_k_eventexec[] = "eventexec"; +static const char __pyx_k_eventexit[] = "eventexit"; +static const char __pyx_k_eventfree[] = "eventfree"; +static const char __pyx_k_eventhdlr[] = "eventhdlr"; +static const char __pyx_k_eventinit[] = "eventinit"; +static const char __pyx_k_eventtype[] = "eventtype"; +static const char __pyx_k_extension[] = "extension"; +static const char __pyx_k_fixedvars[] = "fixedvars"; +static const char __pyx_k_getBounds[] = "getBounds"; +static const char __pyx_k_getDomchg[] = "getDomchg"; +static const char __pyx_k_getNConss[] = "getNConss"; +static const char __pyx_k_getNNodes[] = "getNNodes"; +static const char __pyx_k_getNlRows[] = "getNlRows"; +static const char __pyx_k_getNumber[] = "getNumber"; +static const char __pyx_k_getObjVal[] = "getObjVal"; +static const char __pyx_k_getParams[] = "getParams"; +static const char __pyx_k_getParent[] = "getParent"; +static const char __pyx_k_getPrimal[] = "getPrimal"; +static const char __pyx_k_getSolVal[] = "getSolVal"; +static const char __pyx_k_getStatus[] = "getStatus"; +static const char __pyx_k_getlocale[] = "getlocale"; +static const char __pyx_k_inProbing[] = "inProbing"; +static const char __pyx_k_inferinfo[] = "inferinfo"; +static const char __pyx_k_inforunbd[] = "inforunbd"; +static const char __pyx_k_isChecked[] = "isChecked"; +static const char __pyx_k_isDynamic[] = "isDynamic"; +static const char __pyx_k_isInitial[] = "isInitial"; +static const char __pyx_k_is_number[] = "_is_number"; +static const char __pyx_k_isenabled[] = "isenabled"; +static const char __pyx_k_itertools[] = "itertools"; +static const char __pyx_k_mappedvar[] = "mappedvar"; +static const char __pyx_k_maxnconss[] = "maxnconss"; +static const char __pyx_k_maxrounds[] = "maxrounds"; +static const char __pyx_k_metaclass[] = "__metaclass__"; +static const char __pyx_k_model_cip[] = "model.cip"; +static const char __pyx_k_monomials[] = "monomials"; +static const char __pyx_k_naddconss[] = "naddconss"; +static const char __pyx_k_naddholes[] = "naddholes"; +static const char __pyx_k_naggrvars[] = "naggrvars"; +static const char __pyx_k_nchgcoefs[] = "nchgcoefs"; +static const char __pyx_k_nchgsides[] = "nchgsides"; +static const char __pyx_k_nchildren[] = "nchildren"; +static const char __pyx_k_nconsprop[] = "nconsprop"; +static const char __pyx_k_ndelconss[] = "ndelconss"; +static const char __pyx_k_needscons[] = "needscons"; +static const char __pyx_k_nlocksneg[] = "nlocksneg"; +static const char __pyx_k_nlockspos[] = "nlockspos"; +static const char __pyx_k_nnewholes[] = "nnewholes"; +static const char __pyx_k_nodelimit[] = "nodelimit"; +static const char __pyx_k_nonlinear[] = "nonlinear"; +static const char __pyx_k_normalize[] = "normalize"; +static const char __pyx_k_nsiblings[] = "_nsiblings"; +static const char __pyx_k_objective[] = "objective"; +static const char __pyx_k_objoffset[] = "objoffset"; +static const char __pyx_k_orthofunc[] = "orthofunc"; +static const char __pyx_k_param_set[] = "param.set"; +static const char __pyx_k_paramtype[] = "paramtype"; +static const char __pyx_k_pricedVar[] = "pricedVar"; +static const char __pyx_k_primalsol[] = "primalsol"; +static const char __pyx_k_printCons[] = "printCons"; +static const char __pyx_k_propagate[] = "propagate"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; +static const char __pyx_k_quadratic[] = "quadratic"; +static const char __pyx_k_quadterms[] = "quadterms"; +static const char __pyx_k_quickprod[] = "quickprod"; +static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_relaxcons[] = "relaxcons"; +static const char __pyx_k_relaxedbd[] = "relaxedbd"; +static const char __pyx_k_relaxexec[] = "relaxexec"; +static const char __pyx_k_relaxexit[] = "relaxexit"; +static const char __pyx_k_relaxfree[] = "relaxfree"; +static const char __pyx_k_relaxinit[] = "relaxinit"; +static const char __pyx_k_removable[] = "removable"; +static const char __pyx_k_scip_cons[] = "scip_cons"; +static const char __pyx_k_scip_expr[] = "scip_expr"; +static const char __pyx_k_scip_sepa[] = "scip_sepa"; +static const char __pyx_k_scipexprs[] = "scipexprs"; +static const char __pyx_k_setParams[] = "setParams"; +static const char __pyx_k_setSolVal[] = "setSolVal"; +static const char __pyx_k_setlocale[] = "setlocale"; +static const char __pyx_k_skipsolve[] = "skipsolve"; +static const char __pyx_k_solutions[] = "solutions"; +static const char __pyx_k_startDive[] = "startDive"; +static const char __pyx_k_stopearly[] = "stopearly"; +static const char __pyx_k_temp_cons[] = "temp_cons"; +static const char __pyx_k_termcoefs[] = "termcoefs"; +static const char __pyx_k_tightened[] = "tightened"; +static const char __pyx_k_timelimit[] = "timelimit"; +static const char __pyx_k_transcons[] = "transcons"; +static const char __pyx_k_unbounded[] = "unbounded"; +static const char __pyx_k_validnode[] = "validnode"; +static const char __pyx_k_valuenode[] = "valuenode"; +static const char __pyx_k_variables[] = "variables"; +static const char __pyx_k_writeName[] = "writeName"; +static const char __pyx_k_AGGRESSIVE[] = "AGGRESSIVE"; +static const char __pyx_k_BEFORENODE[] = "BEFORENODE"; +static const char __pyx_k_Benderscut[] = "Benderscut"; +static const char __pyx_k_Branchrule[] = "Branchrule"; +static const char __pyx_k_CONTINUOUS[] = "CONTINUOUS"; +static const char __pyx_k_Constraint[] = "Constraint"; +static const char __pyx_k_DIDNOTFIND[] = "DIDNOTFIND"; +static const char __pyx_k_DOMCHANGED[] = "DOMCHANGED"; +static const char __pyx_k_EXHAUSTIVE[] = "EXHAUSTIVE"; +static const char __pyx_k_EventNames[] = "EventNames"; +static const char __pyx_k_ExprCons_2[] = "ExprCons"; +static const char __pyx_k_GBDCHANGED[] = "GBDCHANGED"; +static const char __pyx_k_GHOLEADDED[] = "GHOLEADDED"; +static const char __pyx_k_GLBCHANGED[] = "GLBCHANGED"; +static const char __pyx_k_GUBCHANGED[] = "GUBCHANGED"; +static const char __pyx_k_INFEASIBLE[] = "INFEASIBLE"; +static const char __pyx_k_LC_NUMERIC[] = "LC_NUMERIC"; +static const char __pyx_k_LHOLEADDED[] = "LHOLEADDED"; +static const char __pyx_k_LP_addCols[] = "LP.addCols"; +static const char __pyx_k_LP_addRows[] = "LP.addRows"; +static const char __pyx_k_LP_chgCoef[] = "LP.chgCoef"; +static const char __pyx_k_LP_chgSide[] = "LP.chgSide"; +static const char __pyx_k_LP_delCols[] = "LP.delCols"; +static const char __pyx_k_LP_delRows[] = "LP.delRows"; +static const char __pyx_k_LP_getDual[] = "LP.getDual"; +static const char __pyx_k_LP_writeLP[] = "LP.writeLP"; +static const char __pyx_k_Model_frac[] = "Model.frac"; +static const char __pyx_k_Model_isEQ[] = "Model.isEQ"; +static const char __pyx_k_Model_isGE[] = "Model.isGE"; +static const char __pyx_k_Model_isGT[] = "Model.isGT"; +static const char __pyx_k_Model_isLE[] = "Model.isLE"; +static const char __pyx_k_Model_isLT[] = "Model.isLT"; +static const char __pyx_k_NODEDELETE[] = "NODEDELETE"; +static const char __pyx_k_NODESOLVED[] = "NODESOLVED"; +static const char __pyx_k_OBJCHANGED[] = "OBJCHANGED"; +static const char __pyx_k_OPTIMALITY[] = "OPTIMALITY"; +static const char __pyx_k_PHASEPROOF[] = "PHASEPROOF"; +static const char __pyx_k_PRESOLVING[] = "PRESOLVING"; +static const char __pyx_k_PSEUDOFORK[] = "PSEUDOFORK"; +static const char __pyx_k_REDUCEDDOM[] = "REDUCEDDOM"; +static const char __pyx_k_ROWADDEDLP[] = "ROWADDEDLP"; +static const char __pyx_k_ROWCHANGED[] = "ROWCHANGED"; +static const char __pyx_k_Row_getLhs[] = "Row.getLhs"; +static const char __pyx_k_Row_getRhs[] = "Row.getRhs"; +static const char __pyx_k_StageNames[] = "StageNames"; +static const char __pyx_k_Term___add[] = "Term.__add__"; +static const char __pyx_k_Term___len[] = "Term.__len__"; +static const char __pyx_k_VARCHANGED[] = "VARCHANGED"; +static const char __pyx_k_VARDELETED[] = "VARDELETED"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_addConsAnd[] = "addConsAnd"; +static const char __pyx_k_addConsXor[] = "addConsXor"; +static const char __pyx_k_addPoolCut[] = "addPoolCut"; +static const char __pyx_k_addRowDive[] = "addRowDive"; +static const char __pyx_k_addVarSOS1[] = "addVarSOS1"; +static const char __pyx_k_addVarSOS2[] = "addVarSOS2"; +static const char __pyx_k_addedconss[] = "addedconss"; +static const char __pyx_k_allowlocal[] = "allowlocal"; +static const char __pyx_k_benderscut[] = "benderscut"; +static const char __pyx_k_bilinterm1[] = "bilinterm1"; +static const char __pyx_k_bilinterm2[] = "bilinterm2"; +static const char __pyx_k_bilinterms[] = "bilinterms"; +static const char __pyx_k_boundtypes[] = "boundtypes"; +static const char __pyx_k_branchexit[] = "branchexit"; +static const char __pyx_k_branchfree[] = "branchfree"; +static const char __pyx_k_branchinit[] = "branchinit"; +static const char __pyx_k_branchrule[] = "branchrule"; +static const char __pyx_k_branchvars[] = "branchvars"; +static const char __pyx_k_catchEvent[] = "catchEvent"; +static const char __pyx_k_checkStage[] = "_checkStage"; +static const char __pyx_k_chgVarType[] = "chgVarType"; +static const char __pyx_k_children_2[] = "_children"; +static const char __pyx_k_completely[] = "completely"; +static const char __pyx_k_consactive[] = "consactive"; +static const char __pyx_k_consdelete[] = "consdelete"; +static const char __pyx_k_consenable[] = "consenable"; +static const char __pyx_k_consenfolp[] = "consenfolp"; +static const char __pyx_k_consenfops[] = "consenfops"; +static const char __pyx_k_consinitlp[] = "consinitlp"; +static const char __pyx_k_conspresol[] = "conspresol"; +static const char __pyx_k_conssepalp[] = "conssepalp"; +static const char __pyx_k_constraint[] = "constraint"; +static const char __pyx_k_createCons[] = "createCons"; +static const char __pyx_k_createscip[] = "createscip"; +static const char __pyx_k_cutselexit[] = "cutselexit"; +static const char __pyx_k_cutselfree[] = "cutselfree"; +static const char __pyx_k_cutselinit[] = "cutselinit"; +static const char __pyx_k_endProbing[] = "endProbing"; +static const char __pyx_k_forcedcuts[] = "forcedcuts"; +static const char __pyx_k_getBestSol[] = "getBestSol"; +static const char __pyx_k_getDualRay[] = "getDualRay"; +static const char __pyx_k_getDualsol[] = "getDualsol"; +static const char __pyx_k_getLbLocal[] = "getLbLocal"; +static const char __pyx_k_getNDomchg[] = "getNDomchg"; +static const char __pyx_k_getNLPCols[] = "getNLPCols"; +static const char __pyx_k_getNLPNonz[] = "getNLPNonz"; +static const char __pyx_k_getNLPRows[] = "getNLPRows"; +static const char __pyx_k_getNLeaves[] = "getNLeaves"; +static const char __pyx_k_getNNlRows[] = "getNNlRows"; +static const char __pyx_k_getPrimsol[] = "getPrimsol"; +static const char __pyx_k_getRedcost[] = "getRedcost"; +static const char __pyx_k_getSolTime[] = "getSolTime"; +static const char __pyx_k_getUbLocal[] = "getUbLocal"; +static const char __pyx_k_getVarDict[] = "getVarDict"; +static const char __pyx_k_globalcopy[] = "globalcopy"; +static const char __pyx_k_heurtiming[] = "heurtiming"; +static const char __pyx_k_hideOutput[] = "hideOutput"; +static const char __pyx_k_infeasible[] = "infeasible"; +static const char __pyx_k_isEnforced[] = "isEnforced"; +static const char __pyx_k_isFeasZero[] = "isFeasZero"; +static const char __pyx_k_isInfinity[] = "isInfinity"; +static const char __pyx_k_isIntegral[] = "isIntegral"; +static const char __pyx_k_isOriginal[] = "isOriginal"; +static const char __pyx_k_is_integer[] = "is_integer"; +static const char __pyx_k_lincoefs_2[] = "_lincoefs"; +static const char __pyx_k_lowerbound[] = "lowerbound"; +static const char __pyx_k_lpcandssol[] = "lpcandssol"; +static const char __pyx_k_modifiable[] = "modifiable"; +static const char __pyx_k_nboundchgs[] = "nboundchgs"; +static const char __pyx_k_nfixedvars[] = "nfixedvars"; +static const char __pyx_k_nlinvars_2[] = "_nlinvars"; +static const char __pyx_k_nlocksdown[] = "nlocksdown"; +static const char __pyx_k_nnewchgbds[] = "nnewchgbds"; +static const char __pyx_k_nodeselect[] = "nodeselect"; +static const char __pyx_k_nquadterms[] = "_nquadterms"; +static const char __pyx_k_nupgdconss[] = "nupgdconss"; +static const char __pyx_k_onlyconvex[] = "onlyconvex"; +static const char __pyx_k_presolexec[] = "presolexec"; +static const char __pyx_k_presolexit[] = "presolexit"; +static const char __pyx_k_presolfree[] = "presolfree"; +static const char __pyx_k_presolinit[] = "presolinit"; +static const char __pyx_k_pricerexit[] = "pricerexit"; +static const char __pyx_k_pricerfree[] = "pricerfree"; +static const char __pyx_k_pricerinit[] = "pricerinit"; +static const char __pyx_k_printNlRow[] = "printNlRow"; +static const char __pyx_k_probnumber[] = "probnumber"; +static const char __pyx_k_proppresol[] = "proppresol"; +static const char __pyx_k_proptiming[] = "proptiming"; +static const char __pyx_k_pyx_result[] = "__pyx_result"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_readParams[] = "readParams"; +static const char __pyx_k_readerfree[] = "readerfree"; +static const char __pyx_k_readerread[] = "readerread"; +static const char __pyx_k_releaseRow[] = "releaseRow"; +static const char __pyx_k_resetParam[] = "resetParam"; +static const char __pyx_k_sepaexeclp[] = "sepaexeclp"; +static const char __pyx_k_setInitial[] = "setInitial"; +static const char __pyx_k_setLogfile[] = "setLogfile"; +static const char __pyx_k_siblings_2[] = "siblings"; +static const char __pyx_k_startnvars[] = "startnvars"; +static const char __pyx_k_subproblem[] = "subproblem"; +static const char __pyx_k_targetcons[] = "targetcons"; +static const char __pyx_k_threadsafe[] = "threadsafe"; +static const char __pyx_k_timingmask[] = "timingmask"; +static const char __pyx_k_vars_array[] = "vars_array"; +static const char __pyx_k_AFTERLPLOOP[] = "AFTERLPLOOP"; +static const char __pyx_k_AFTERLPNODE[] = "AFTERLPNODE"; +static const char __pyx_k_BoundChange[] = "BoundChange"; +static const char __pyx_k_CONSCHANGED[] = "CONSCHANGED"; +static const char __pyx_k_Expr_degree[] = "Expr.degree"; +static const char __pyx_k_FEASIBILITY[] = "FEASIBILITY"; +static const char __pyx_k_HOLECHANGED[] = "HOLECHANGED"; +static const char __pyx_k_LBTIGHTENED[] = "LBTIGHTENED"; +static const char __pyx_k_LP_chgBound[] = "LP.chgBound"; +static const char __pyx_k_LP_getSides[] = "LP.getSides"; +static const char __pyx_k_LP_infinity[] = "LP.infinity"; +static const char __pyx_k_LookupError[] = "LookupError"; +static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_Model_count[] = "Model.count"; +static const char __pyx_k_Model_relax[] = "Model.relax"; +static const char __pyx_k_NODEFOCUSED[] = "NODEFOCUSED"; +static const char __pyx_k_PRIMALLIMIT[] = "PRIMALLIMIT"; +static const char __pyx_k_PROBINGNODE[] = "PROBINGNODE"; +static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_REFOCUSNODE[] = "REFOCUSNODE"; +static const char __pyx_k_Row_getCols[] = "Row.getCols"; +static const char __pyx_k_Row_getNorm[] = "Row.getNorm"; +static const char __pyx_k_Row_getVals[] = "Row.getVals"; +static const char __pyx_k_Row_isLocal[] = "Row.isLocal"; +static const char __pyx_k_TRANSFORMED[] = "TRANSFORMED"; +static const char __pyx_k_Term___hash[] = "Term.__hash__"; +static const char __pyx_k_Term___init[] = "Term.__init__"; +static const char __pyx_k_Term___repr[] = "Term.__repr__"; +static const char __pyx_k_UBTIGHTENED[] = "UBTIGHTENED"; +static const char __pyx_k_VARUNLOCKED[] = "VARUNLOCKED"; +static const char __pyx_k_addConsNode[] = "addConsNode"; +static const char __pyx_k_addConsSOS1[] = "addConsSOS1"; +static const char __pyx_k_addConsSOS2[] = "addConsSOS2"; +static const char __pyx_k_addVarLocks[] = "addVarLocks"; +static const char __pyx_k_addVarToRow[] = "addVarToRow"; +static const char __pyx_k_bendersexit[] = "bendersexit"; +static const char __pyx_k_bendersfree[] = "bendersfree"; +static const char __pyx_k_bendersinit[] = "bendersinit"; +static const char __pyx_k_c_primalsol[] = "c_primalsol"; +static const char __pyx_k_checkbounds[] = "checkbounds"; +static const char __pyx_k_checklprows[] = "checklprows"; +static const char __pyx_k_consdelvars[] = "consdelvars"; +static const char __pyx_k_consdisable[] = "consdisable"; +static const char __pyx_k_consexitpre[] = "consexitpre"; +static const char __pyx_k_consexitsol[] = "consexitsol"; +static const char __pyx_k_consgetvars[] = "consgetvars"; +static const char __pyx_k_consinitpre[] = "consinitpre"; +static const char __pyx_k_consinitsol[] = "consinitsol"; +static const char __pyx_k_consresprop[] = "consresprop"; +static const char __pyx_k_conssepasol[] = "conssepasol"; +static const char __pyx_k_constraints[] = "constraints"; +static const char __pyx_k_constructLP[] = "constructLP"; +static const char __pyx_k_createChild[] = "createChild"; +static const char __pyx_k_entrieslist[] = "entrieslist"; +static const char __pyx_k_eventdelete[] = "eventdelete"; +static const char __pyx_k_eventhdlr_2[] = "_eventhdlr"; +static const char __pyx_k_feasibility[] = "feasibility"; +static const char __pyx_k_getActivity[] = "getActivity"; +static const char __pyx_k_getBestLeaf[] = "getBestLeaf"; +static const char __pyx_k_getBestNode[] = "getBestNode"; +static const char __pyx_k_getConsVars[] = "getConsVars"; +static const char __pyx_k_getConstant[] = "getConstant"; +static const char __pyx_k_getEstimate[] = "getEstimate"; +static const char __pyx_k_getLPObjVal[] = "getLPObjVal"; +static const char __pyx_k_getLbGlobal[] = "getLbGlobal"; +static const char __pyx_k_getNBinVars[] = "getNBinVars"; +static const char __pyx_k_getNIntVars[] = "getNIntVars"; +static const char __pyx_k_getNReaders[] = "getNReaders"; +static const char __pyx_k_getNewBound[] = "getNewBound"; +static const char __pyx_k_getObjCoeff[] = "getObjCoeff"; +static const char __pyx_k_getObjlimit[] = "getObjlimit"; +static const char __pyx_k_getOldBound[] = "getOldBound"; +static const char __pyx_k_getProbName[] = "getProbName"; +static const char __pyx_k_getUbGlobal[] = "getUbGlobal"; +static const char __pyx_k_heurexitsol[] = "heurexitsol"; +static const char __pyx_k_heurinitsol[] = "heurinitsol"; +static const char __pyx_k_includeHeur[] = "includeHeur"; +static const char __pyx_k_includeProp[] = "includeProp"; +static const char __pyx_k_includeSepa[] = "includeSepa"; +static const char __pyx_k_isNonlinear[] = "isNonlinear"; +static const char __pyx_k_isRedundant[] = "isRedundant"; +static const char __pyx_k_isRemovable[] = "isRemovable"; +static const char __pyx_k_isSeparated[] = "isSeparated"; +static const char __pyx_k_isquadratic[] = "isquadratic"; +static const char __pyx_k_lowerbounds[] = "lowerbounds"; +static const char __pyx_k_lpcandsfrac[] = "lpcandsfrac"; +static const char __pyx_k_mappedvar_2[] = "_mappedvar"; +static const char __pyx_k_maxactivity[] = "maxactivity"; +static const char __pyx_k_minactivity[] = "minactivity"; +static const char __pyx_k_nbilinterms[] = "_nbilinterms"; +static const char __pyx_k_nbranchings[] = "nbranchings"; +static const char __pyx_k_nbranchvars[] = "nbranchvars"; +static const char __pyx_k_nchildren_2[] = "_nchildren"; +static const char __pyx_k_nodeexitsol[] = "nodeexitsol"; +static const char __pyx_k_nodeinitsol[] = "nodeinitsol"; +static const char __pyx_k_nodeselprio[] = "nodeselprio"; +static const char __pyx_k_onlychanged[] = "onlychanged"; +static const char __pyx_k_onlydelayed[] = "onlydelayed"; +static const char __pyx_k_pretendroot[] = "pretendroot"; +static const char __pyx_k_primallimit[] = "primallimit"; +static const char __pyx_k_printreason[] = "printreason"; +static const char __pyx_k_problemName[] = "problemName"; +static const char __pyx_k_propexitpre[] = "propexitpre"; +static const char __pyx_k_propexitsol[] = "propexitsol"; +static const char __pyx_k_propinitpre[] = "propinitpre"; +static const char __pyx_k_propinitsol[] = "propinitsol"; +static const char __pyx_k_propresprop[] = "propresprop"; +static const char __pyx_k_pseudocands[] = "pseudocands"; +static const char __pyx_k_raise_error[] = "raise_error"; +static const char __pyx_k_readProblem[] = "readProblem"; +static const char __pyx_k_readSolFile[] = "readSolFile"; +static const char __pyx_k_readerwrite[] = "readerwrite"; +static const char __pyx_k_resetParams[] = "resetParams"; +static const char __pyx_k_result_dict[] = "result_dict"; +static const char __pyx_k_scip_pricer[] = "scip_pricer"; +static const char __pyx_k_sepaexecsol[] = "sepaexecsol"; +static const char __pyx_k_sepaexitsol[] = "sepaexitsol"; +static const char __pyx_k_sepainitsol[] = "sepainitsol"; +static const char __pyx_k_separateSol[] = "separateSol"; +static const char __pyx_k_setEmphasis[] = "setEmphasis"; +static const char __pyx_k_setEnforced[] = "setEnforced"; +static const char __pyx_k_setIntParam[] = "setIntParam"; +static const char __pyx_k_setMaximize[] = "setMaximize"; +static const char __pyx_k_setMinimize[] = "setMinimize"; +static const char __pyx_k_setObjlimit[] = "setObjlimit"; +static const char __pyx_k_setPresolve[] = "setPresolve"; +static const char __pyx_k_setProbName[] = "setProbName"; +static const char __pyx_k_solveDiveLP[] = "solveDiveLP"; +static const char __pyx_k_sourceModel[] = "sourceModel"; +static const char __pyx_k_startnconss[] = "startnconss"; +static const char __pyx_k_stdpriority[] = "stdpriority"; +static const char __pyx_k_str_absfile[] = "str_absfile"; +static const char __pyx_k_subproblems[] = "subproblems"; +static const char __pyx_k_targetvalue[] = "targetvalue"; +static const char __pyx_k_transformed[] = "transformed"; +static const char __pyx_k_user_locale[] = "user_locale"; +static const char __pyx_k_usessubscip[] = "usessubscip"; +static const char __pyx_k_writeParams[] = "writeParams"; +static const char __pyx_k_write_zeros[] = "write_zeros"; +static const char __pyx_k_BEFOREPRESOL[] = "BEFOREPRESOL"; +static const char __pyx_k_BESTSOLFOUND[] = "BESTSOLFOUND"; +static const char __pyx_k_BESTSOLLIMIT[] = "BESTSOLLIMIT"; +static const char __pyx_k_BOUNDCHANGED[] = "BOUNDCHANGED"; +static const char __pyx_k_BOUNDRELAXED[] = "BOUNDRELAXED"; +static const char __pyx_k_Column_getLb[] = "Column.getLb"; +static const char __pyx_k_Column_getUb[] = "Column.getUb"; +static const char __pyx_k_DURINGLPLOOP[] = "DURINGLPLOOP"; +static const char __pyx_k_EXITPRESOLVE[] = "EXITPRESOLVE"; +static const char __pyx_k_Event_getRow[] = "Event.getRow"; +static const char __pyx_k_Event_getVar[] = "Event.getVar"; +static const char __pyx_k_GHOLECHANGED[] = "GHOLECHANGED"; +static const char __pyx_k_GHOLEREMOVED[] = "GHOLEREMOVED"; +static const char __pyx_k_INITPRESOLVE[] = "INITPRESOLVE"; +static const char __pyx_k_LHOLECHANGED[] = "LHOLECHANGED"; +static const char __pyx_k_LHOLEREMOVED[] = "LHOLEREMOVED"; +static const char __pyx_k_LP_getBounds[] = "LP.getBounds"; +static const char __pyx_k_LP_getPrimal[] = "LP.getPrimal"; +static const char __pyx_k_Model_addCut[] = "Model.addCut"; +static const char __pyx_k_Model_addSol[] = "Model.addSol"; +static const char __pyx_k_Model_addVar[] = "Model.addVar"; +static const char __pyx_k_Model_chgLhs[] = "Model.chgLhs"; +static const char __pyx_k_Model_chgRhs[] = "Model.chgRhs"; +static const char __pyx_k_Model_delVar[] = "Model.delVar"; +static const char __pyx_k_Model_fixVar[] = "Model.fixVar"; +static const char __pyx_k_Model_getGap[] = "Model.getGap"; +static const char __pyx_k_Model_getLhs[] = "Model.getLhs"; +static const char __pyx_k_Model_getRhs[] = "Model.getRhs"; +static const char __pyx_k_Model_getVal[] = "Model.getVal"; +static const char __pyx_k_Model_isZero[] = "Model.isZero"; +static const char __pyx_k_Model_to_ptr[] = "Model.to_ptr"; +static const char __pyx_k_Model_trySol[] = "Model.trySol"; +static const char __pyx_k_NLRow_getLhs[] = "NLRow.getLhs"; +static const char __pyx_k_NLRow_getRhs[] = "NLRow.getRhs"; +static const char __pyx_k_NODEBRANCHED[] = "NODEBRANCHED"; +static const char __pyx_k_NODEFEASIBLE[] = "NODEFEASIBLE"; +static const char __pyx_k_Node_getType[] = "Node.getType"; +static const char __pyx_k_PHASEIMPROVE[] = "PHASEIMPROVE"; +static const char __pyx_k_POORSOLFOUND[] = "POORSOLFOUND"; +static const char __pyx_k_PY_SCIP_CALL[] = "PY_SCIP_CALL"; +static const char __pyx_k_RESTARTLIMIT[] = "RESTARTLIMIT"; +static const char __pyx_k_ROWADDEDSEPA[] = "ROWADDEDSEPA"; +static const char __pyx_k_ROWDELETEDLP[] = "ROWDELETEDLP"; +static const char __pyx_k_Row_getLPPos[] = "Row.getLPPos"; +static const char __pyx_k_Row_getNNonz[] = "Row.getNNonz"; +static const char __pyx_k_TRANSFORMING[] = "TRANSFORMING"; +static const char __pyx_k_UNBOUNDEDRAY[] = "UNBOUNDEDRAY"; +static const char __pyx_k_Variable_ptr[] = "Variable.ptr"; +static const char __pyx_k_addConsCoeff[] = "addConsCoeff"; +static const char __pyx_k_addConsLocal[] = "addConsLocal"; +static const char __pyx_k_addObjoffset[] = "addObjoffset"; +static const char __pyx_k_allowaddcons[] = "allowaddcons"; +static const char __pyx_k_bestsollimit[] = "bestsollimit"; +static const char __pyx_k_branchVarVal[] = "branchVarVal"; +static const char __pyx_k_branchbounds[] = "branchbounds"; +static const char __pyx_k_branchexeclp[] = "branchexeclp"; +static const char __pyx_k_branchexecps[] = "branchexecps"; +static const char __pyx_k_chckpriority[] = "chckpriority"; +static const char __pyx_k_chgVarLbDive[] = "chgVarLbDive"; +static const char __pyx_k_chgVarLbNode[] = "chgVarLbNode"; +static const char __pyx_k_chgVarUbDive[] = "chgVarUbDive"; +static const char __pyx_k_chgVarUbNode[] = "chgVarUbNode"; +static const char __pyx_k_childrenexpr[] = "childrenexpr"; +static const char __pyx_k_coeffs_array[] = "coeffs_array"; +static const char __pyx_k_consdeactive[] = "consdeactive"; +static const char __pyx_k_consgetnvars[] = "consgetnvars"; +static const char __pyx_k_conshdrlname[] = "conshdrlname"; +static const char __pyx_k_cutselselect[] = "cutselselect"; +static const char __pyx_k_delConsLocal[] = "delConsLocal"; +static const char __pyx_k_dropRowEvent[] = "dropRowEvent"; +static const char __pyx_k_dropVarEvent[] = "dropVarEvent"; +static const char __pyx_k_enfopriority[] = "enfopriority"; +static const char __pyx_k_eventexitsol[] = "eventexitsol"; +static const char __pyx_k_eventinitsol[] = "eventinitsol"; +static const char __pyx_k_expr_richcmp[] = "_expr_richcmp"; +static const char __pyx_k_genericnames[] = "genericnames"; +static const char __pyx_k_getBasisInds[] = "getBasisInds"; +static const char __pyx_k_getBestChild[] = "getBestChild"; +static const char __pyx_k_getBoundchgs[] = "getBoundchgs"; +static const char __pyx_k_getBoundtype[] = "getBoundtype"; +static const char __pyx_k_getCondition[] = "getCondition"; +static const char __pyx_k_getConsNVars[] = "getConsNVars"; +static const char __pyx_k_getDualbound[] = "getDualbound"; +static const char __pyx_k_getLPBInvRow[] = "getLPBInvRow"; +static const char __pyx_k_getLPSolstat[] = "getLPSolstat"; +static const char __pyx_k_getNChildren[] = "getNChildren"; +static const char __pyx_k_getNSiblings[] = "getNSiblings"; +static const char __pyx_k_getObjective[] = "getObjective"; +static const char __pyx_k_getObjoffset[] = "getObjoffset"; +static const char __pyx_k_getOpenNodes[] = "getOpenNodes"; +static const char __pyx_k_getPrimalRay[] = "getPrimalRay"; +static const char __pyx_k_getRowLinear[] = "getRowLinear"; +static const char __pyx_k_getSolObjVal[] = "getSolObjVal"; +static const char __pyx_k_getStageName[] = "getStageName"; +static const char __pyx_k_getTotalTime[] = "getTotalTime"; +static const char __pyx_k_getVarLbDive[] = "getVarLbDive"; +static const char __pyx_k_getVarUbDive[] = "getVarUbDive"; +static const char __pyx_k_hasPrimalRay[] = "hasPrimalRay"; +static const char __pyx_k_includeRelax[] = "includeRelax"; +static const char __pyx_k_infeasible_2[] = "_infeasible"; +static const char __pyx_k_initializing[] = "_initializing"; +static const char __pyx_k_isLPSolBasic[] = "isLPSolBasic"; +static const char __pyx_k_isModifiable[] = "isModifiable"; +static const char __pyx_k_isPropagated[] = "isPropagated"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; +static const char __pyx_k_maxbounddist[] = "maxbounddist"; +static const char __pyx_k_maxprerounds[] = "maxprerounds"; +static const char __pyx_k_nchgvartypes[] = "nchgvartypes"; +static const char __pyx_k_nmarkedconss[] = "nmarkedconss"; +static const char __pyx_k_nnewaddconss[] = "nnewaddconss"; +static const char __pyx_k_nnewaddholes[] = "nnewaddholes"; +static const char __pyx_k_nnewaggrvars[] = "nnewaggrvars"; +static const char __pyx_k_nnewchgcoefs[] = "nnewchgcoefs"; +static const char __pyx_k_nnewchgsides[] = "nnewchgsides"; +static const char __pyx_k_nnewdelconss[] = "nnewdelconss"; +static const char __pyx_k_npriolpcands[] = "npriolpcands"; +static const char __pyx_k_npseudocands[] = "npseudocands"; +static const char __pyx_k_nsubproblems[] = "nsubproblems"; +static const char __pyx_k_nusefulconss[] = "nusefulconss"; +static const char __pyx_k_origprob_sol[] = "origprob.sol"; +static const char __pyx_k_paraemphasis[] = "paraemphasis"; +static const char __pyx_k_presoltiming[] = "presoltiming"; +static const char __pyx_k_pricerfarkas[] = "pricerfarkas"; +static const char __pyx_k_printBestSol[] = "printBestSol"; +static const char __pyx_k_printVersion[] = "printVersion"; +static const char __pyx_k_probingdepth[] = "probingdepth"; +static const char __pyx_k_py_variables[] = "py_variables"; +static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; +static const char __pyx_k_relaxexitsol[] = "relaxexitsol"; +static const char __pyx_k_relaxinitsol[] = "relaxinitsol"; +static const char __pyx_k_restartSolve[] = "restartSolve"; +static const char __pyx_k_restartlimit[] = "restartlimit"; +static const char __pyx_k_scip_benders[] = "scip_benders"; +static const char __pyx_k_scip_subprob[] = "scip_subprob"; +static const char __pyx_k_sepapriority[] = "sepapriority"; +static const char __pyx_k_setBoolParam[] = "setBoolParam"; +static const char __pyx_k_setCharParam[] = "setCharParam"; +static const char __pyx_k_setObjective[] = "setObjective"; +static const char __pyx_k_setRealParam[] = "setRealParam"; +static const char __pyx_k_setRemovable[] = "setRemovable"; +static const char __pyx_k_startProbing[] = "startProbing"; +static const char __pyx_k_staticmethod[] = "staticmethod"; +static const char __pyx_k_stringsource[] = ""; +static const char __pyx_k_tightenVarLb[] = "tightenVarLb"; +static const char __pyx_k_tightenVarUb[] = "tightenVarUb"; +static const char __pyx_k_use_setstate[] = "use_setstate"; +static const char __pyx_k_version_info[] = "version_info"; +static const char __pyx_k_writeBestSol[] = "writeBestSol"; +static const char __pyx_k_writeProblem[] = "writeProblem"; +static const char __pyx_k_AFTERLPPLUNGE[] = "AFTERLPPLUNGE"; +static const char __pyx_k_AFTERPROPLOOP[] = "AFTERPROPLOOP"; +static const char __pyx_k_Column_getVar[] = "Column.getVar"; +static const char __pyx_k_DomainChanges[] = "DomainChanges"; +static const char __pyx_k_Event_getName[] = "Event.getName"; +static const char __pyx_k_Event_getNode[] = "Event.getNode"; +static const char __pyx_k_Event_getType[] = "Event.getType"; +static const char __pyx_k_FIRSTLPSOLVED[] = "FIRSTLPSOLVED"; +static const char __pyx_k_GenExpr_getOp[] = "GenExpr.getOp"; +static const char __pyx_k_Heur_heurexec[] = "Heur.heurexec"; +static const char __pyx_k_Heur_heurexit[] = "Heur.heurexit"; +static const char __pyx_k_Heur_heurfree[] = "Heur.heurfree"; +static const char __pyx_k_Heur_heurinit[] = "Heur.heurinit"; +static const char __pyx_k_IndicatorCons[] = "IndicatorCons"; +static const char __pyx_k_LP_getDualRay[] = "LP.getDualRay"; +static const char __pyx_k_LP_getRedcost[] = "LP.getRedcost"; +static const char __pyx_k_LP_isInfinity[] = "LP.isInfinity"; +static const char __pyx_k_Model_addCons[] = "Model.addCons"; +static const char __pyx_k_Model_delCons[] = "Model.delCons"; +static const char __pyx_k_Model_endDive[] = "Model.endDive"; +static const char __pyx_k_Model_epsilon[] = "Model.epsilon"; +static const char __pyx_k_Model_feastol[] = "Model.feastol"; +static const char __pyx_k_Model_freeSol[] = "Model.freeSol"; +static const char __pyx_k_Model_getNLPs[] = "Model.getNLPs"; +static const char __pyx_k_Model_getSols[] = "Model.getSols"; +static const char __pyx_k_Model_getVars[] = "Model.getVars"; +static const char __pyx_k_Model_readSol[] = "Model.readSol"; +static const char __pyx_k_Model_version[] = "Model.version"; +static const char __pyx_k_Model_writeLP[] = "Model.writeLP"; +static const char __pyx_k_Node_getDepth[] = "Node.getDepth"; +static const char __pyx_k_Node_isActive[] = "Node.isActive"; +static const char __pyx_k_PRESOLVEROUND[] = "PRESOLVEROUND"; +static const char __pyx_k_PY_SCIP_STAGE[] = "PY_SCIP_STAGE"; +static const char __pyx_k_Prop_propexec[] = "Prop.propexec"; +static const char __pyx_k_Prop_propexit[] = "Prop.propexit"; +static const char __pyx_k_Prop_propfree[] = "Prop.propfree"; +static const char __pyx_k_Prop_propinit[] = "Prop.propinit"; +static const char __pyx_k_SCIPgetSolVal[] = "SCIPgetSolVal"; +static const char __pyx_k_Sepa_sepaexit[] = "Sepa.sepaexit"; +static const char __pyx_k_Sepa_sepafree[] = "Sepa.sepafree"; +static const char __pyx_k_Sepa_sepainit[] = "Sepa.sepainit"; +static const char __pyx_k_StopIteration[] = "StopIteration"; +static const char __pyx_k_USERINTERRUPT[] = "USERINTERRUPT"; +static const char __pyx_k_addCoefLinear[] = "addCoefLinear"; +static const char __pyx_k_appendVarSOS1[] = "appendVarSOS1"; +static const char __pyx_k_appendVarSOS2[] = "appendVarSOS2"; +static const char __pyx_k_bendersgetvar[] = "bendersgetvar"; +static const char __pyx_k_branchexecext[] = "branchexecext"; +static const char __pyx_k_branchexitsol[] = "branchexitsol"; +static const char __pyx_k_branchinitsol[] = "branchinitsol"; +static const char __pyx_k_catchRowEvent[] = "catchRowEvent"; +static const char __pyx_k_catchVarEvent[] = "catchVarEvent"; +static const char __pyx_k_chgCoefLinear[] = "chgCoefLinear"; +static const char __pyx_k_chgRowLhsDive[] = "chgRowLhsDive"; +static const char __pyx_k_chgRowRhsDive[] = "chgRowRhsDive"; +static const char __pyx_k_chgVarObjDive[] = "chgVarObjDive"; +static const char __pyx_k_class_getitem[] = "__class_getitem__"; +static const char __pyx_k_consenforelax[] = "consenforelax"; +static const char __pyx_k_createOrigSol[] = "createOrigSol"; +static const char __pyx_k_cutselexitsol[] = "cutselexitsol"; +static const char __pyx_k_cutselinitsol[] = "cutselinitsol"; +static const char __pyx_k_delCoefLinear[] = "delCoefLinear"; +static const char __pyx_k_enablepricing[] = "enablepricing"; +static const char __pyx_k_expr_to_array[] = "expr_to_array"; +static const char __pyx_k_expr_to_nodes[] = "expr_to_nodes"; +static const char __pyx_k_fixVarProbing[] = "fixVarProbing"; +static const char __pyx_k_freeTransform[] = "freeTransform"; +static const char __pyx_k_getAddedConss[] = "getAddedConss"; +static const char __pyx_k_getBendersVar[] = "getBendersVar"; +static const char __pyx_k_getDualSolVal[] = "getDualSolVal"; +static const char __pyx_k_getEventNames[] = "_getEventNames"; +static const char __pyx_k_getLPBInvARow[] = "getLPBInvARow"; +static const char __pyx_k_getLPBasisInd[] = "getLPBasisInd"; +static const char __pyx_k_getLPColsData[] = "getLPColsData"; +static const char __pyx_k_getLPRowsData[] = "getLPRowsData"; +static const char __pyx_k_getLbOriginal[] = "getLbOriginal"; +static const char __pyx_k_getLowerbound[] = "getLowerbound"; +static const char __pyx_k_getNSolsFound[] = "getNSolsFound"; +static const char __pyx_k_getOrigintype[] = "getOrigintype"; +static const char __pyx_k_getRowDualSol[] = "getRowDualSol"; +static const char __pyx_k_getStageNames[] = "_getStageNames"; +static const char __pyx_k_getUbOriginal[] = "getUbOriginal"; +static const char __pyx_k_getValsLinear[] = "getValsLinear"; +static const char __pyx_k_getVarRedcost[] = "getVarRedcost"; +static const char __pyx_k_includeCutsel[] = "includeCutsel"; +static const char __pyx_k_includePresol[] = "includePresol"; +static const char __pyx_k_includePricer[] = "includePricer"; +static const char __pyx_k_includeReader[] = "includeReader"; +static const char __pyx_k_init_subclass[] = "__init_subclass__"; +static const char __pyx_k_maxproprounds[] = "maxproprounds"; +static const char __pyx_k_ndomredsfound[] = "ndomredsfound"; +static const char __pyx_k_nfracimplvars[] = "nfracimplvars"; +static const char __pyx_k_nnewfixedvars[] = "nnewfixedvars"; +static const char __pyx_k_nnewupgdconss[] = "nnewupgdconss"; +static const char __pyx_k_nselectedcuts[] = "nselectedcuts"; +static const char __pyx_k_objinfeasible[] = "objinfeasible"; +static const char __pyx_k_presolexitpre[] = "presolexitpre"; +static const char __pyx_k_presolinitpre[] = "presolinitpre"; +static const char __pyx_k_pricerexitsol[] = "pricerexitsol"; +static const char __pyx_k_pricerinitsol[] = "pricerinitsol"; +static const char __pyx_k_pricerredcost[] = "pricerredcost"; +static const char __pyx_k_py_boundtypes[] = "py_boundtypes"; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_scip_conshdlr[] = "scip_conshdlr"; +static const char __pyx_k_setHeuristics[] = "setHeuristics"; +static const char __pyx_k_setSeparating[] = "setSeparating"; +static const char __pyx_k_solinfeasible[] = "solinfeasible"; +static const char __pyx_k_transprob_sol[] = "transprob.sol"; +static const char __pyx_k_userinterrupt[] = "userinterrupt"; +static const char __pyx_k_writeTransSol[] = "writeTransSol"; +static const char __pyx_k_AssertionError[] = "AssertionError"; +static const char __pyx_k_BOUNDTIGHTENED[] = "BOUNDTIGHTENED"; +static const char __pyx_k_Expr_normalize[] = "Expr.normalize"; +static const char __pyx_k_GenExpr_degree[] = "GenExpr.degree"; +static const char __pyx_k_Model_addConss[] = "Model.addConss"; +static const char __pyx_k_Model_checkSol[] = "Model.checkSol"; +static const char __pyx_k_Model_chgVarLb[] = "Model.chgVarLb"; +static const char __pyx_k_Model_chgVarUb[] = "Model.chgVarUb"; +static const char __pyx_k_Model_feasFrac[] = "Model.feasFrac"; +static const char __pyx_k_Model_freeProb[] = "Model.freeProb"; +static const char __pyx_k_Model_from_ptr[] = "Model.from_ptr"; +static const char __pyx_k_Model_getConss[] = "Model.getConss"; +static const char __pyx_k_Model_getDepth[] = "Model.getDepth"; +static const char __pyx_k_Model_getNCuts[] = "Model.getNCuts"; +static const char __pyx_k_Model_getNSols[] = "Model.getNSols"; +static const char __pyx_k_Model_getNVars[] = "Model.getNVars"; +static const char __pyx_k_Model_getParam[] = "Model.getParam"; +static const char __pyx_k_Model_getSlack[] = "Model.getSlack"; +static const char __pyx_k_Model_getStage[] = "Model.getStage"; +static const char __pyx_k_Model_infinity[] = "Model.infinity"; +static const char __pyx_k_Model_isFeasEQ[] = "Model.isFeasEQ"; +static const char __pyx_k_Model_optimize[] = "Model.optimize"; +static const char __pyx_k_Model_presolve[] = "Model.presolve"; +static const char __pyx_k_Model_printRow[] = "Model.printRow"; +static const char __pyx_k_Model_printSol[] = "Model.printSol"; +static const char __pyx_k_Model_setCheck[] = "Model.setCheck"; +static const char __pyx_k_Model_setParam[] = "Model.setParam"; +static const char __pyx_k_Model_writeSol[] = "Model.writeSol"; +static const char __pyx_k_NODEINFEASIBLE[] = "NODEINFEASIBLE"; +static const char __pyx_k_Node_getDomchg[] = "Node.getDomchg"; +static const char __pyx_k_Node_getNumber[] = "Node.getNumber"; +static const char __pyx_k_Node_getParent[] = "Node.getParent"; +static const char __pyx_k_PY_SCIP_RESULT[] = "PY_SCIP_RESULT"; +static const char __pyx_k_PY_SCIP_STATUS[] = "PY_SCIP_STATUS"; +static const char __pyx_k_ROWCOEFCHANGED[] = "ROWCOEFCHANGED"; +static const char __pyx_k_ROWDELETEDSEPA[] = "ROWDELETEDSEPA"; +static const char __pyx_k_ROWSIDECHANGED[] = "ROWSIDECHANGED"; +static const char __pyx_k_Row_getNLPNonz[] = "Row.getNLPNonz"; +static const char __pyx_k_Row_isIntegral[] = "Row.isIntegral"; +static const char __pyx_k_STALLNODELIMIT[] = "STALLNODELIMIT"; +static const char __pyx_k_TOTALNODELIMIT[] = "TOTALNODELIMIT"; +static const char __pyx_k_Term___getitem[] = "Term.__getitem__"; +static const char __pyx_k_Variable_vtype[] = "Variable.vtype"; +static const char __pyx_k_addedconsssize[] = "addedconsssize"; +static const char __pyx_k_benderscutexec[] = "benderscutexec"; +static const char __pyx_k_benderscutexit[] = "benderscutexit"; +static const char __pyx_k_benderscutfree[] = "benderscutfree"; +static const char __pyx_k_benderscutinit[] = "benderscutinit"; +static const char __pyx_k_bendersexitpre[] = "bendersexitpre"; +static const char __pyx_k_bendersexitsol[] = "bendersexitsol"; +static const char __pyx_k_bendersfreesub[] = "bendersfreesub"; +static const char __pyx_k_bendersinitpre[] = "bendersinitpre"; +static const char __pyx_k_bendersinitsol[] = "bendersinitsol"; +static const char __pyx_k_chgVarLbGlobal[] = "chgVarLbGlobal"; +static const char __pyx_k_chgVarUbGlobal[] = "chgVarUbGlobal"; +static const char __pyx_k_defaultPlugins[] = "defaultPlugins"; +static const char __pyx_k_freeReoptSolve[] = "freeReoptSolve"; +static const char __pyx_k_getBasisStatus[] = "getBasisStatus"; +static const char __pyx_k_getBestSibling[] = "getBestSibling"; +static const char __pyx_k_getCurrentNode[] = "getCurrentNode"; +static const char __pyx_k_getCutEfficacy[] = "getCutEfficacy"; +static const char __pyx_k_getLinearTerms[] = "getLinearTerms"; +static const char __pyx_k_getNAddedConss[] = "getNAddedConss"; +static const char __pyx_k_getNIterations[] = "getNIterations"; +static const char __pyx_k_getNSepaRounds[] = "getNSepaRounds"; +static const char __pyx_k_getNTotalNodes[] = "getNTotalNodes"; +static const char __pyx_k_getPrimalbound[] = "getPrimalbound"; +static const char __pyx_k_getReadingTime[] = "getReadingTime"; +static const char __pyx_k_getRowActivity[] = "getRowActivity"; +static const char __pyx_k_getSolvingTime[] = "getSolvingTime"; +static const char __pyx_k_give_ownership[] = "give_ownership"; +static const char __pyx_k_includeBenders[] = "includeBenders"; +static const char __pyx_k_includeNodesel[] = "includeNodesel"; +static const char __pyx_k_interruptSolve[] = "interruptSolve"; +static const char __pyx_k_isDualFeasible[] = "isDualFeasible"; +static const char __pyx_k_isFeasIntegral[] = "isFeasIntegral"; +static const char __pyx_k_isFeasNegative[] = "isFeasNegative"; +static const char __pyx_k_newProbingNode[] = "newProbingNode"; +static const char __pyx_k_nodeinfeasible[] = "nodeinfeasible"; +static const char __pyx_k_origprob_stats[] = "origprob.stats"; +static const char __pyx_k_presolpriority[] = "presolpriority"; +static const char __pyx_k_pricedVarScore[] = "pricedVarScore"; +static const char __pyx_k_pycons_initial[] = "pycons_initial"; +static const char __pyx_k_pyscipopt_scip[] = "pyscipopt.scip"; +static const char __pyx_k_redirectOutput[] = "redirectOutput"; +static const char __pyx_k_setObjIntegral[] = "setObjIntegral"; +static const char __pyx_k_setRelaxSolVal[] = "setRelaxSolVal"; +static const char __pyx_k_setStringParam[] = "setStringParam"; +static const char __pyx_k_solveProbingLP[] = "solveProbingLP"; +static const char __pyx_k_stallnodelimit[] = "stallnodelimit"; +static const char __pyx_k_stickingatnode[] = "stickingatnode"; +static const char __pyx_k_str_conversion[] = "str_conversion"; +static const char __pyx_k_take_ownership[] = "take_ownership"; +static const char __pyx_k_totalnodelimit[] = "totalnodelimit"; +static const char __pyx_k_value_to_array[] = "value_to_array"; +static const char __pyx_k_AFTERPSEUDONODE[] = "AFTERPSEUDONODE"; +static const char __pyx_k_CardinalityCons[] = "CardinalityCons"; +static const char __pyx_k_Column_getLPPos[] = "Column.getLPPos"; +static const char __pyx_k_LP_getBasisInds[] = "LP.getBasisInds"; +static const char __pyx_k_LP_getPrimalRay[] = "LP.getPrimalRay"; +static const char __pyx_k_Model_addConsOr[] = "Model.addConsOr"; +static const char __pyx_k_Model_addPyCons[] = "Model.addPyCons"; +static const char __pyx_k_Model_branchVar[] = "Model.branchVar"; +static const char __pyx_k_Model_createSol[] = "Model.createSol"; +static const char __pyx_k_Model_dropEvent[] = "Model.dropEvent"; +static const char __pyx_k_Model_getNConss[] = "Model.getNConss"; +static const char __pyx_k_Model_getNNodes[] = "Model.getNNodes"; +static const char __pyx_k_Model_getNlRows[] = "Model.getNlRows"; +static const char __pyx_k_Model_getObjVal[] = "Model.getObjVal"; +static const char __pyx_k_Model_getParams[] = "Model.getParams"; +static const char __pyx_k_Model_getSolVal[] = "Model.getSolVal"; +static const char __pyx_k_Model_getStatus[] = "Model.getStatus"; +static const char __pyx_k_Model_inProbing[] = "Model.inProbing"; +static const char __pyx_k_Model_printCons[] = "Model.printCons"; +static const char __pyx_k_Model_setParams[] = "Model.setParams"; +static const char __pyx_k_Model_setSolVal[] = "Model.setSolVal"; +static const char __pyx_k_Model_startDive[] = "Model.startDive"; +static const char __pyx_k_Model_writeName[] = "Model.writeName"; +static const char __pyx_k_Node_getNDomchg[] = "Node.getNDomchg"; +static const char __pyx_k_Prop_proppresol[] = "Prop.proppresol"; +static const char __pyx_k_ROWCONSTCHANGED[] = "ROWCONSTCHANGED"; +static const char __pyx_k_Relax_relaxexec[] = "Relax.relaxexec"; +static const char __pyx_k_Relax_relaxexit[] = "Relax.relaxexit"; +static const char __pyx_k_Relax_relaxfree[] = "Relax.relaxfree"; +static const char __pyx_k_Relax_relaxinit[] = "Relax.relaxinit"; +static const char __pyx_k_Row_getConstant[] = "Row.getConstant"; +static const char __pyx_k_Row_isRemovable[] = "Row.isRemovable"; +static const char __pyx_k_SCIP_read_error[] = "SCIP: read error!"; +static const char __pyx_k_Sepa_sepaexeclp[] = "Sepa.sepaexeclp"; +static const char __pyx_k_Variable_getCol[] = "Variable.getCol"; +static const char __pyx_k_Variable_getObj[] = "Variable.getObj"; +static const char __pyx_k_Variable_isInLP[] = "Variable.isInLP"; +static const char __pyx_k_activateBenders[] = "activateBenders"; +static const char __pyx_k_benderssolvesub[] = "benderssolvesub"; +static const char __pyx_k_boundconstraint[] = "boundconstraint"; +static const char __pyx_k_buildGenExprObj[] = "buildGenExprObj"; +static const char __pyx_k_chgVarLbProbing[] = "chgVarLbProbing"; +static const char __pyx_k_chgVarUbProbing[] = "chgVarUbProbing"; +static const char __pyx_k_collections_abc[] = "collections.abc"; +static const char __pyx_k_createProbBasic[] = "createProbBasic"; +static const char __pyx_k_ensure_iterable[] = "ensure_iterable"; +static const char __pyx_k_getBoundchgtype[] = "getBoundchgtype"; +static const char __pyx_k_getConshdlrName[] = "getConshdlrName"; +static const char __pyx_k_getNCountedSols[] = "getNCountedSols"; +static const char __pyx_k_getNCutsApplied[] = "getNCutsApplied"; +static const char __pyx_k_getPrimalRayVal[] = "getPrimalRayVal"; +static const char __pyx_k_getProbingDepth[] = "getProbingDepth"; +static const char __pyx_k_inRepropagation[] = "inRepropagation"; +static const char __pyx_k_includeConshdlr[] = "includeConshdlr"; +static const char __pyx_k_is_memory_freed[] = "is_memory_freed"; +static const char __pyx_k_memsavepriority[] = "memsavepriority"; +static const char __pyx_k_mergecandidates[] = "mergecandidates"; +static const char __pyx_k_nnewchgvartypes[] = "nnewchgvartypes"; +static const char __pyx_k_npriomergecands[] = "npriomergecands"; +static const char __pyx_k_partialsolution[] = "partialsolution"; +static const char __pyx_k_presolmaxrounds[] = "presolmaxrounds"; +static const char __pyx_k_printStatistics[] = "printStatistics"; +static const char __pyx_k_py_branchbounds[] = "py_branchbounds"; +static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; +static const char __pyx_k_repropagateNode[] = "repropagateNode"; +static const char __pyx_k_scip_benderscut[] = "scip_benderscut"; +static const char __pyx_k_setLongintParam[] = "setLongintParam"; +static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_solveConcurrent[] = "solveConcurrent"; +static const char __pyx_k_writeStatistics[] = "writeStatistics"; +static const char __pyx_k_DURINGPRESOLLOOP[] = "DURINGPRESOLLOOP"; +static const char __pyx_k_Heur_heurexitsol[] = "Heur.heurexitsol"; +static const char __pyx_k_Heur_heurinitsol[] = "Heur.heurinitsol"; +static const char __pyx_k_Model_addConsAnd[] = "Model.addConsAnd"; +static const char __pyx_k_Model_addConsXor[] = "Model.addConsXor"; +static const char __pyx_k_Model_addPoolCut[] = "Model.addPoolCut"; +static const char __pyx_k_Model_addRowDive[] = "Model.addRowDive"; +static const char __pyx_k_Model_addVarSOS1[] = "Model.addVarSOS1"; +static const char __pyx_k_Model_addVarSOS2[] = "Model.addVarSOS2"; +static const char __pyx_k_Model_catchEvent[] = "Model.catchEvent"; +static const char __pyx_k_Model_chgVarType[] = "Model.chgVarType"; +static const char __pyx_k_Model_createCons[] = "Model.createCons"; +static const char __pyx_k_Model_endProbing[] = "Model.endProbing"; +static const char __pyx_k_Model_getBestSol[] = "Model.getBestSol"; +static const char __pyx_k_Model_getNLPCols[] = "Model.getNLPCols"; +static const char __pyx_k_Model_getNLPRows[] = "Model.getNLPRows"; +static const char __pyx_k_Model_getNLeaves[] = "Model.getNLeaves"; +static const char __pyx_k_Model_getNNlRows[] = "Model.getNNlRows"; +static const char __pyx_k_Model_getSolTime[] = "Model.getSolTime"; +static const char __pyx_k_Model_getVarDict[] = "Model.getVarDict"; +static const char __pyx_k_Model_hideOutput[] = "Model.hideOutput"; +static const char __pyx_k_Model_isFeasZero[] = "Model.isFeasZero"; +static const char __pyx_k_Model_isInfinity[] = "Model.isInfinity"; +static const char __pyx_k_Model_printNlRow[] = "Model.printNlRow"; +static const char __pyx_k_Model_readParams[] = "Model.readParams"; +static const char __pyx_k_Model_releaseRow[] = "Model.releaseRow"; +static const char __pyx_k_Model_resetParam[] = "Model.resetParam"; +static const char __pyx_k_Model_setInitial[] = "Model.setInitial"; +static const char __pyx_k_Model_setLogfile[] = "Model.setLogfile"; +static const char __pyx_k_NLRow_getDualsol[] = "NLRow.getDualsol"; +static const char __pyx_k_Node_getEstimate[] = "Node.getEstimate"; +static const char __pyx_k_Nodesel_nodecomp[] = "Nodesel.nodecomp"; +static const char __pyx_k_Nodesel_nodeexit[] = "Nodesel.nodeexit"; +static const char __pyx_k_Nodesel_nodefree[] = "Nodesel.nodefree"; +static const char __pyx_k_Nodesel_nodeinit[] = "Nodesel.nodeinit"; +static const char __pyx_k_PY_SCIP_NODETYPE[] = "PY_SCIP_NODETYPE"; +static const char __pyx_k_Prop_propexitpre[] = "Prop.propexitpre"; +static const char __pyx_k_Prop_propexitsol[] = "Prop.propexitsol"; +static const char __pyx_k_Prop_propinitpre[] = "Prop.propinitpre"; +static const char __pyx_k_Prop_propinitsol[] = "Prop.propinitsol"; +static const char __pyx_k_Prop_propresprop[] = "Prop.propresprop"; +static const char __pyx_k_Row_isModifiable[] = "Row.isModifiable"; +static const char __pyx_k_SCIP_write_error[] = "SCIP: write error!"; +static const char __pyx_k_Sepa_sepaexecsol[] = "Sepa.sepaexecsol"; +static const char __pyx_k_Sepa_sepaexitsol[] = "Sepa.sepaexitsol"; +static const char __pyx_k_Sepa_sepainitsol[] = "Sepa.sepainitsol"; +static const char __pyx_k_addConsIndicator[] = "addConsIndicator"; +static const char __pyx_k_addExprNonlinear[] = "addExprNonlinear"; +static const char __pyx_k_applyCutsProbing[] = "applyCutsProbing"; +static const char __pyx_k_backtrackProbing[] = "backtrackProbing"; +static const char __pyx_k_benderscreatesub[] = "benderscreatesub"; +static const char __pyx_k_benderspostsolve[] = "benderspostsolve"; +static const char __pyx_k_checkintegrality[] = "checkintegrality"; +static const char __pyx_k_chgVarObjProbing[] = "chgVarObjProbing"; +static const char __pyx_k_createConsLinear[] = "_createConsLinear"; +static const char __pyx_k_createPartialSol[] = "createPartialSol"; +static const char __pyx_k_dummy_boundtypes[] = "dummy_boundtypes"; +static const char __pyx_k_dummy_branchvars[] = "dummy_branchvars"; +static const char __pyx_k_getBestboundNode[] = "getBestboundNode"; +static const char __pyx_k_getDualboundRoot[] = "getDualboundRoot"; +static const char __pyx_k_getDualsolLinear[] = "getDualsolLinear"; +static const char __pyx_k_getLPBranchCands[] = "getLPBranchCands"; +static const char __pyx_k_getLocalEstimate[] = "getLocalEstimate"; +static const char __pyx_k_getNLPIterations[] = "getNLPIterations"; +static const char __pyx_k_getNLimSolsFound[] = "getNLimSolsFound"; +static const char __pyx_k_getRowLPActivity[] = "getRowLPActivity"; +static const char __pyx_k_getRowNumIntCols[] = "getRowNumIntCols"; +static const char __pyx_k_includeEventhdlr[] = "includeEventhdlr"; +static const char __pyx_k_isCutEfficacious[] = "isCutEfficacious"; +static const char __pyx_k_isNLPConstructed[] = "isNLPConstructed"; +static const char __pyx_k_isPrimalFeasible[] = "isPrimalFeasible"; +static const char __pyx_k_isStickingAtNode[] = "isStickingAtNode"; +static const char __pyx_k_lpiGetIterations[] = "lpiGetIterations"; +static const char __pyx_k_maxnselectedcuts[] = "maxnselectedcuts"; +static const char __pyx_k_myMessageHandler[] = "myMessageHandler"; +static const char __pyx_k_npriopseudocands[] = "npriopseudocands"; +static const char __pyx_k_propagateProbing[] = "propagateProbing"; +static const char __pyx_k_sourceconstraint[] = "sourceconstraint"; +static const char __pyx_k_AFTERPSEUDOPLUNGE[] = "AFTERPSEUDOPLUNGE"; +static const char __pyx_k_Column_getPrimsol[] = "Column.getPrimsol"; +static const char __pyx_k_Column_isIntegral[] = "Column.isIntegral"; +static const char __pyx_k_Conshdlr_conscopy[] = "Conshdlr.conscopy"; +static const char __pyx_k_Conshdlr_consexit[] = "Conshdlr.consexit"; +static const char __pyx_k_Conshdlr_consfree[] = "Conshdlr.consfree"; +static const char __pyx_k_Conshdlr_consinit[] = "Conshdlr.consinit"; +static const char __pyx_k_Conshdlr_conslock[] = "Conshdlr.conslock"; +static const char __pyx_k_Conshdlr_consprop[] = "Conshdlr.consprop"; +static const char __pyx_k_Cutsel_cutselexit[] = "Cutsel.cutselexit"; +static const char __pyx_k_Cutsel_cutselfree[] = "Cutsel.cutselfree"; +static const char __pyx_k_Cutsel_cutselinit[] = "Cutsel.cutselinit"; +static const char __pyx_k_DURINGPRICINGLOOP[] = "DURINGPRICINGLOOP"; +static const char __pyx_k_Event_getNewBound[] = "Event.getNewBound"; +static const char __pyx_k_Event_getOldBound[] = "Event.getOldBound"; +static const char __pyx_k_LP_getNIterations[] = "LP.getNIterations"; +static const char __pyx_k_LP_isDualFeasible[] = "LP.isDualFeasible"; +static const char __pyx_k_Model_addConsNode[] = "Model.addConsNode"; +static const char __pyx_k_Model_addConsSOS1[] = "Model.addConsSOS1"; +static const char __pyx_k_Model_addConsSOS2[] = "Model.addConsSOS2"; +static const char __pyx_k_Model_addVarLocks[] = "Model.addVarLocks"; +static const char __pyx_k_Model_addVarToRow[] = "Model.addVarToRow"; +static const char __pyx_k_Model_constructLP[] = "Model.constructLP"; +static const char __pyx_k_Model_createChild[] = "Model.createChild"; +static const char __pyx_k_Model_getActivity[] = "Model.getActivity"; +static const char __pyx_k_Model_getBestLeaf[] = "Model.getBestLeaf"; +static const char __pyx_k_Model_getBestNode[] = "Model.getBestNode"; +static const char __pyx_k_Model_getConsVars[] = "Model.getConsVars"; +static const char __pyx_k_Model_getLPObjVal[] = "Model.getLPObjVal"; +static const char __pyx_k_Model_getNBinVars[] = "Model.getNBinVars"; +static const char __pyx_k_Model_getNIntVars[] = "Model.getNIntVars"; +static const char __pyx_k_Model_getNReaders[] = "Model.getNReaders"; +static const char __pyx_k_Model_getObjlimit[] = "Model.getObjlimit"; +static const char __pyx_k_Model_getProbName[] = "Model.getProbName"; +static const char __pyx_k_Model_includeHeur[] = "Model.includeHeur"; +static const char __pyx_k_Model_includeProp[] = "Model.includeProp"; +static const char __pyx_k_Model_includeSepa[] = "Model.includeSepa"; +static const char __pyx_k_Model_readProblem[] = "Model.readProblem"; +static const char __pyx_k_Model_readSolFile[] = "Model.readSolFile"; +static const char __pyx_k_Model_resetParams[] = "Model.resetParams"; +static const char __pyx_k_Model_separateSol[] = "Model.separateSol"; +static const char __pyx_k_Model_setEmphasis[] = "Model.setEmphasis"; +static const char __pyx_k_Model_setEnforced[] = "Model.setEnforced"; +static const char __pyx_k_Model_setIntParam[] = "Model.setIntParam"; +static const char __pyx_k_Model_setMaximize[] = "Model.setMaximize"; +static const char __pyx_k_Model_setMinimize[] = "Model.setMinimize"; +static const char __pyx_k_Model_setObjlimit[] = "Model.setObjlimit"; +static const char __pyx_k_Model_setPresolve[] = "Model.setPresolve"; +static const char __pyx_k_Model_setProbName[] = "Model.setProbName"; +static const char __pyx_k_Model_solveDiveLP[] = "Model.solveDiveLP"; +static const char __pyx_k_Model_writeParams[] = "Model.writeParams"; +static const char __pyx_k_NLRow_getConstant[] = "NLRow.getConstant"; +static const char __pyx_k_PY_SCIP_BRANCHDIR[] = "PY_SCIP_BRANCHDIR"; +static const char __pyx_k_PY_SCIP_EVENTTYPE[] = "PY_SCIP_EVENTTYPE"; +static const char __pyx_k_PY_SCIP_LPSOLSTAT[] = "PY_SCIP_LPSOLSTAT"; +static const char __pyx_k_Presol_presolexec[] = "Presol.presolexec"; +static const char __pyx_k_Presol_presolexit[] = "Presol.presolexit"; +static const char __pyx_k_Presol_presolfree[] = "Presol.presolfree"; +static const char __pyx_k_Presol_presolinit[] = "Presol.presolinit"; +static const char __pyx_k_Pricer_pricerexit[] = "Pricer.pricerexit"; +static const char __pyx_k_Pricer_pricerfree[] = "Pricer.pricerfree"; +static const char __pyx_k_Pricer_pricerinit[] = "Pricer.pricerinit"; +static const char __pyx_k_Reader_readerfree[] = "Reader.readerfree"; +static const char __pyx_k_Reader_readerread[] = "Reader.readerread"; +static const char __pyx_k_Row_getOrigintype[] = "Row.getOrigintype"; +static const char __pyx_k_Variable_getIndex[] = "Variable.getIndex"; +static const char __pyx_k_Variable_getLPSol[] = "Variable.getLPSol"; +static const char __pyx_k_ZeroDivisionError[] = "ZeroDivisionError"; +static const char __pyx_k_benderscutexitsol[] = "benderscutexitsol"; +static const char __pyx_k_benderscutinitsol[] = "benderscutinitsol"; +static const char __pyx_k_calcChildEstimate[] = "calcChildEstimate"; +static const char __pyx_k_chgReoptObjective[] = "chgReoptObjective"; +static const char __pyx_k_consgetdivebdchgs[] = "consgetdivebdchgs"; +static const char __pyx_k_getDualMultiplier[] = "getDualMultiplier"; +static const char __pyx_k_getNBestSolsFound[] = "getNBestSolsFound"; +static const char __pyx_k_getObjectiveSense[] = "getObjectiveSense"; +static const char __pyx_k_getPresolvingTime[] = "getPresolvingTime"; +static const char __pyx_k_getRowParallelism[] = "getRowParallelism"; +static const char __pyx_k_getTermsQuadratic[] = "getTermsQuadratic"; +static const char __pyx_k_getTransformedVar[] = "getTransformedVar"; +static const char __pyx_k_includeBenderscut[] = "includeBenderscut"; +static const char __pyx_k_includeBranchrule[] = "includeBranchrule"; +static const char __pyx_k_isInGlobalCutpool[] = "isInGlobalCutpool"; +static const char __pyx_k_isPropagatedAgain[] = "isPropagatedAgain"; +static const char __pyx_k_pyx_unpickle_Expr[] = "__pyx_unpickle_Expr"; +static const char __pyx_k_pyx_unpickle_Heur[] = "__pyx_unpickle_Heur"; +static const char __pyx_k_pyx_unpickle_Prop[] = "__pyx_unpickle_Prop"; +static const char __pyx_k_pyx_unpickle_Sepa[] = "__pyx_unpickle_Sepa"; +static const char __pyx_k_writeBestTransSol[] = "writeBestTransSol"; +static const char __pyx_k_BoundChange_getVar[] = "BoundChange.getVar"; +static const char __pyx_k_Column_getObjCoeff[] = "Column.getObjCoeff"; +static const char __pyx_k_Conshdlr_conscheck[] = "Conshdlr.conscheck"; +static const char __pyx_k_Conshdlr_consparse[] = "Conshdlr.consparse"; +static const char __pyx_k_Conshdlr_consprint[] = "Conshdlr.consprint"; +static const char __pyx_k_Conshdlr_constrans[] = "Conshdlr.constrans"; +static const char __pyx_k_Constraint_isLocal[] = "Constraint.isLocal"; +static const char __pyx_k_ExprCons_normalize[] = "ExprCons.normalize"; +static const char __pyx_k_LP___reduce_cython[] = "LP.__reduce_cython__"; +static const char __pyx_k_Model_addConsCoeff[] = "Model.addConsCoeff"; +static const char __pyx_k_Model_addConsLocal[] = "Model.addConsLocal"; +static const char __pyx_k_Model_addObjoffset[] = "Model.addObjoffset"; +static const char __pyx_k_Model_branchVarVal[] = "Model.branchVarVal"; +static const char __pyx_k_Model_chgVarLbDive[] = "Model.chgVarLbDive"; +static const char __pyx_k_Model_chgVarLbNode[] = "Model.chgVarLbNode"; +static const char __pyx_k_Model_chgVarUbDive[] = "Model.chgVarUbDive"; +static const char __pyx_k_Model_chgVarUbNode[] = "Model.chgVarUbNode"; +static const char __pyx_k_Model_delConsLocal[] = "Model.delConsLocal"; +static const char __pyx_k_Model_dropRowEvent[] = "Model.dropRowEvent"; +static const char __pyx_k_Model_dropVarEvent[] = "Model.dropVarEvent"; +static const char __pyx_k_Model_getBestChild[] = "Model.getBestChild"; +static const char __pyx_k_Model_getCondition[] = "Model.getCondition"; +static const char __pyx_k_Model_getConsNVars[] = "Model.getConsNVars"; +static const char __pyx_k_Model_getDualbound[] = "Model.getDualbound"; +static const char __pyx_k_Model_getLPBInvRow[] = "Model.getLPBInvRow"; +static const char __pyx_k_Model_getLPSolstat[] = "Model.getLPSolstat"; +static const char __pyx_k_Model_getNChildren[] = "Model.getNChildren"; +static const char __pyx_k_Model_getNSiblings[] = "Model.getNSiblings"; +static const char __pyx_k_Model_getObjective[] = "Model.getObjective"; +static const char __pyx_k_Model_getObjoffset[] = "Model.getObjoffset"; +static const char __pyx_k_Model_getOpenNodes[] = "Model.getOpenNodes"; +static const char __pyx_k_Model_getPrimalRay[] = "Model.getPrimalRay"; +static const char __pyx_k_Model_getRowLinear[] = "Model.getRowLinear"; +static const char __pyx_k_Model_getSolObjVal[] = "Model.getSolObjVal"; +static const char __pyx_k_Model_getStageName[] = "Model.getStageName"; +static const char __pyx_k_Model_getTotalTime[] = "Model.getTotalTime"; +static const char __pyx_k_Model_getVarLbDive[] = "Model.getVarLbDive"; +static const char __pyx_k_Model_getVarUbDive[] = "Model.getVarUbDive"; +static const char __pyx_k_Model_hasPrimalRay[] = "Model.hasPrimalRay"; +static const char __pyx_k_Model_includeRelax[] = "Model.includeRelax"; +static const char __pyx_k_Model_isLPSolBasic[] = "Model.isLPSolBasic"; +static const char __pyx_k_Model_printBestSol[] = "Model.printBestSol"; +static const char __pyx_k_Model_printVersion[] = "Model.printVersion"; +static const char __pyx_k_Model_restartSolve[] = "Model.restartSolve"; +static const char __pyx_k_Model_setBoolParam[] = "Model.setBoolParam"; +static const char __pyx_k_Model_setCharParam[] = "Model.setCharParam"; +static const char __pyx_k_Model_setObjective[] = "Model.setObjective"; +static const char __pyx_k_Model_setRealParam[] = "Model.setRealParam"; +static const char __pyx_k_Model_setRemovable[] = "Model.setRemovable"; +static const char __pyx_k_Model_startProbing[] = "Model.startProbing"; +static const char __pyx_k_Model_tightenVarLb[] = "Model.tightenVarLb"; +static const char __pyx_k_Model_tightenVarUb[] = "Model.tightenVarUb"; +static const char __pyx_k_Model_writeBestSol[] = "Model.writeBestSol"; +static const char __pyx_k_Model_writeProblem[] = "Model.writeProblem"; +static const char __pyx_k_Node_getAddedConss[] = "Node.getAddedConss"; +static const char __pyx_k_Node_getLowerbound[] = "Node.getLowerbound"; +static const char __pyx_k_Nodesel_nodeselect[] = "Nodesel.nodeselect"; +static const char __pyx_k_PY_SCIP_HEURTIMING[] = "PY_SCIP_HEURTIMING"; +static const char __pyx_k_PY_SCIP_PROPTIMING[] = "PY_SCIP_PROPTIMING"; +static const char __pyx_k_Reader_readerwrite[] = "Reader.readerwrite"; +static const char __pyx_k_Relax_relaxexitsol[] = "Relax.relaxexitsol"; +static const char __pyx_k_Relax_relaxinitsol[] = "Relax.relaxinitsol"; +static const char __pyx_k_Row_getBasisStatus[] = "Row.getBasisStatus"; +static const char __pyx_k_Solution__evaluate[] = "Solution._evaluate"; +static const char __pyx_k_Union_Expr_GenExpr[] = "Union[Expr, GenExpr]"; +static const char __pyx_k_addConsCardinality[] = "addConsCardinality"; +static const char __pyx_k_addConsDisjunction[] = "addConsDisjunction"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; +static const char __pyx_k_benderspresubsolve[] = "benderspresubsolve"; +static const char __pyx_k_cacheRowExtensions[] = "cacheRowExtensions"; +static const char __pyx_k_cannot_divide_by_0[] = "cannot divide by 0"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_createConsFromExpr[] = "createConsFromExpr"; +static const char __pyx_k_createEmptyRowSepa[] = "createEmptyRowSepa"; +static const char __pyx_k_disablePropagation[] = "disablePropagation"; +static const char __pyx_k_dummy_branchbounds[] = "dummy_branchbounds"; +static const char __pyx_k_flushRowExtensions[] = "flushRowExtensions"; +static const char __pyx_k_getNFeasibleLeaves[] = "getNFeasibleLeaves"; +static const char __pyx_k_getTransformedCons[] = "getTransformedCons"; +static const char __pyx_k_initBendersDefault[] = "initBendersDefault"; +static const char __pyx_k_pyx_unpickle_Relax[] = "__pyx_unpickle_Relax"; +static const char __pyx_k_setParamsCountsols[] = "setParamsCountsols"; +static const char __pyx_k_tightenVarLbGlobal[] = "tightenVarLbGlobal"; +static const char __pyx_k_tightenVarUbGlobal[] = "tightenVarUbGlobal"; +static const char __pyx_k_Benders_bendersexit[] = "Benders.bendersexit"; +static const char __pyx_k_Benders_bendersfree[] = "Benders.bendersfree"; +static const char __pyx_k_Benders_bendersinit[] = "Benders.bendersinit"; +static const char __pyx_k_Conshdlr_consactive[] = "Conshdlr.consactive"; +static const char __pyx_k_Conshdlr_consdelete[] = "Conshdlr.consdelete"; +static const char __pyx_k_Conshdlr_consenable[] = "Conshdlr.consenable"; +static const char __pyx_k_Conshdlr_consenfolp[] = "Conshdlr.consenfolp"; +static const char __pyx_k_Conshdlr_consenfops[] = "Conshdlr.consenfops"; +static const char __pyx_k_Conshdlr_consinitlp[] = "Conshdlr.consinitlp"; +static const char __pyx_k_Conshdlr_conspresol[] = "Conshdlr.conspresol"; +static const char __pyx_k_Conshdlr_conssepalp[] = "Conshdlr.conssepalp"; +static const char __pyx_k_Constraint_isActive[] = "Constraint.isActive"; +static const char __pyx_k_Constraint_isLinear[] = "Constraint.isLinear"; +static const char __pyx_k_Cutsel_cutselselect[] = "Cutsel.cutselselect"; +static const char __pyx_k_Eventhdlr_eventcopy[] = "Eventhdlr.eventcopy"; +static const char __pyx_k_Eventhdlr_eventexec[] = "Eventhdlr.eventexec"; +static const char __pyx_k_Eventhdlr_eventexit[] = "Eventhdlr.eventexit"; +static const char __pyx_k_Eventhdlr_eventfree[] = "Eventhdlr.eventfree"; +static const char __pyx_k_Eventhdlr_eventinit[] = "Eventhdlr.eventinit"; +static const char __pyx_k_LP_isPrimalFeasible[] = "LP.isPrimalFeasible"; +static const char __pyx_k_Model_addCoefLinear[] = "Model.addCoefLinear"; +static const char __pyx_k_Model_appendVarSOS1[] = "Model.appendVarSOS1"; +static const char __pyx_k_Model_appendVarSOS2[] = "Model.appendVarSOS2"; +static const char __pyx_k_Model_catchRowEvent[] = "Model.catchRowEvent"; +static const char __pyx_k_Model_catchVarEvent[] = "Model.catchVarEvent"; +static const char __pyx_k_Model_chgCoefLinear[] = "Model.chgCoefLinear"; +static const char __pyx_k_Model_chgRowLhsDive[] = "Model.chgRowLhsDive"; +static const char __pyx_k_Model_chgRowRhsDive[] = "Model.chgRowRhsDive"; +static const char __pyx_k_Model_chgVarObjDive[] = "Model.chgVarObjDive"; +static const char __pyx_k_Model_createOrigSol[] = "Model.createOrigSol"; +static const char __pyx_k_Model_delCoefLinear[] = "Model.delCoefLinear"; +static const char __pyx_k_Model_fixVarProbing[] = "Model.fixVarProbing"; +static const char __pyx_k_Model_freeTransform[] = "Model.freeTransform"; +static const char __pyx_k_Model_getBendersVar[] = "Model.getBendersVar"; +static const char __pyx_k_Model_getDualSolVal[] = "Model.getDualSolVal"; +static const char __pyx_k_Model_getLPBInvARow[] = "Model.getLPBInvARow"; +static const char __pyx_k_Model_getLPBasisInd[] = "Model.getLPBasisInd"; +static const char __pyx_k_Model_getLPColsData[] = "Model.getLPColsData"; +static const char __pyx_k_Model_getLPRowsData[] = "Model.getLPRowsData"; +static const char __pyx_k_Model_getNSolsFound[] = "Model.getNSolsFound"; +static const char __pyx_k_Model_getRowDualSol[] = "Model.getRowDualSol"; +static const char __pyx_k_Model_getValsLinear[] = "Model.getValsLinear"; +static const char __pyx_k_Model_getVarRedcost[] = "Model.getVarRedcost"; +static const char __pyx_k_Model_includeCutsel[] = "Model.includeCutsel"; +static const char __pyx_k_Model_includePresol[] = "Model.includePresol"; +static const char __pyx_k_Model_includePricer[] = "Model.includePricer"; +static const char __pyx_k_Model_includeReader[] = "Model.includeReader"; +static const char __pyx_k_Model_setHeuristics[] = "Model.setHeuristics"; +static const char __pyx_k_Model_setSeparating[] = "Model.setSeparating"; +static const char __pyx_k_Model_writeTransSol[] = "Model.writeTransSol"; +static const char __pyx_k_Node_getNAddedConss[] = "Node.getNAddedConss"; +static const char __pyx_k_Nodesel_nodeexitsol[] = "Nodesel.nodeexitsol"; +static const char __pyx_k_Nodesel_nodeinitsol[] = "Nodesel.nodeinitsol"; +static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; +static const char __pyx_k_Pricer_pricerfarkas[] = "Pricer.pricerfarkas"; +static const char __pyx_k_Row___reduce_cython[] = "Row.__reduce_cython__"; +static const char __pyx_k_Variable_getLbLocal[] = "Variable.getLbLocal"; +static const char __pyx_k_Variable_getUbLocal[] = "Variable.getUbLocal"; +static const char __pyx_k_Variable_isOriginal[] = "Variable.isOriginal"; +static const char __pyx_k_calcNodeselPriority[] = "calcNodeselPriority"; +static const char __pyx_k_consgetpermsymgraph[] = "consgetpermsymgraph"; +static const char __pyx_k_createConsNonlinear[] = "_createConsNonlinear"; +static const char __pyx_k_createConsQuadratic[] = "_createConsQuadratic"; +static const char __pyx_k_getDualfarkasLinear[] = "getDualfarkasLinear"; +static const char __pyx_k_getNlRowSolActivity[] = "getNlRowSolActivity"; +static const char __pyx_k_getParentBranchings[] = "getParentBranchings"; +static const char __pyx_k_isObjChangedProbing[] = "isObjChangedProbing"; +static const char __pyx_k_print_memory_in_use[] = "print_memory_in_use"; +static const char __pyx_k_pyx_unpickle_Cutsel[] = "__pyx_unpickle_Cutsel"; +static const char __pyx_k_pyx_unpickle_Presol[] = "__pyx_unpickle_Presol"; +static const char __pyx_k_pyx_unpickle_Pricer[] = "__pyx_unpickle_Pricer"; +static const char __pyx_k_pyx_unpickle_Reader[] = "__pyx_unpickle_Reader"; +static const char __pyx_k_Conshdlr_consdelvars[] = "Conshdlr.consdelvars"; +static const char __pyx_k_Conshdlr_consdisable[] = "Conshdlr.consdisable"; +static const char __pyx_k_Conshdlr_consexitpre[] = "Conshdlr.consexitpre"; +static const char __pyx_k_Conshdlr_consexitsol[] = "Conshdlr.consexitsol"; +static const char __pyx_k_Conshdlr_consgetvars[] = "Conshdlr.consgetvars"; +static const char __pyx_k_Conshdlr_consinitpre[] = "Conshdlr.consinitpre"; +static const char __pyx_k_Conshdlr_consinitsol[] = "Conshdlr.consinitsol"; +static const char __pyx_k_Conshdlr_consresprop[] = "Conshdlr.consresprop"; +static const char __pyx_k_Conshdlr_conssepasol[] = "Conshdlr.conssepasol"; +static const char __pyx_k_Constraint_isChecked[] = "Constraint.isChecked"; +static const char __pyx_k_Constraint_isDynamic[] = "Constraint.isDynamic"; +static const char __pyx_k_Constraint_isInitial[] = "Constraint.isInitial"; +static const char __pyx_k_Cutsel_cutselexitsol[] = "Cutsel.cutselexitsol"; +static const char __pyx_k_Cutsel_cutselinitsol[] = "Cutsel.cutselinitsol"; +static const char __pyx_k_Event__getEventNames[] = "Event._getEventNames"; +static const char __pyx_k_Expr___reduce_cython[] = "Expr.__reduce_cython__"; +static const char __pyx_k_Heur___reduce_cython[] = "Heur.__reduce_cython__"; +static const char __pyx_k_LP___setstate_cython[] = "LP.__setstate_cython__"; +static const char __pyx_k_Model__getStageNames[] = "Model._getStageNames"; +static const char __pyx_k_Model_chgVarLbGlobal[] = "Model.chgVarLbGlobal"; +static const char __pyx_k_Model_chgVarUbGlobal[] = "Model.chgVarUbGlobal"; +static const char __pyx_k_Model_freeReoptSolve[] = "Model.freeReoptSolve"; +static const char __pyx_k_Model_getBestSibling[] = "Model.getBestSibling"; +static const char __pyx_k_Model_getCurrentNode[] = "Model.getCurrentNode"; +static const char __pyx_k_Model_getCutEfficacy[] = "Model.getCutEfficacy"; +static const char __pyx_k_Model_getNSepaRounds[] = "Model.getNSepaRounds"; +static const char __pyx_k_Model_getNTotalNodes[] = "Model.getNTotalNodes"; +static const char __pyx_k_Model_getPrimalbound[] = "Model.getPrimalbound"; +static const char __pyx_k_Model_getReadingTime[] = "Model.getReadingTime"; +static const char __pyx_k_Model_getRowActivity[] = "Model.getRowActivity"; +static const char __pyx_k_Model_getSolvingTime[] = "Model.getSolvingTime"; +static const char __pyx_k_Model_includeBenders[] = "Model.includeBenders"; +static const char __pyx_k_Model_includeNodesel[] = "Model.includeNodesel"; +static const char __pyx_k_Model_interruptSolve[] = "Model.interruptSolve"; +static const char __pyx_k_Model_isFeasIntegral[] = "Model.isFeasIntegral"; +static const char __pyx_k_Model_isFeasNegative[] = "Model.isFeasNegative"; +static const char __pyx_k_Model_newProbingNode[] = "Model.newProbingNode"; +static const char __pyx_k_Model_redirectOutput[] = "Model.redirectOutput"; +static const char __pyx_k_Model_setObjIntegral[] = "Model.setObjIntegral"; +static const char __pyx_k_Model_setRelaxSolVal[] = "Model.setRelaxSolVal"; +static const char __pyx_k_Model_setStringParam[] = "Model.setStringParam"; +static const char __pyx_k_Model_solveProbingLP[] = "Model.solveProbingLP"; +static const char __pyx_k_NLRow_getLinearTerms[] = "NLRow.getLinearTerms"; +static const char __pyx_k_Node___reduce_cython[] = "Node.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_PARAMSETTING[] = "PY_SCIP_PARAMSETTING"; +static const char __pyx_k_PY_SCIP_PRESOLTIMING[] = "PY_SCIP_PRESOLTIMING"; +static const char __pyx_k_Presol_presolexitpre[] = "Presol.presolexitpre"; +static const char __pyx_k_Presol_presolinitpre[] = "Presol.presolinitpre"; +static const char __pyx_k_Pricer_pricerexitsol[] = "Pricer.pricerexitsol"; +static const char __pyx_k_Pricer_pricerinitsol[] = "Pricer.pricerinitsol"; +static const char __pyx_k_Pricer_pricerredcost[] = "Pricer.pricerredcost"; +static const char __pyx_k_Prop___reduce_cython[] = "Prop.__reduce_cython__"; +static const char __pyx_k_Sepa___reduce_cython[] = "Sepa.__reduce_cython__"; +static const char __pyx_k_Solution__checkStage[] = "Solution._checkStage"; +static const char __pyx_k_Variable_getLbGlobal[] = "Variable.getLbGlobal"; +static const char __pyx_k_Variable_getUbGlobal[] = "Variable.getUbGlobal"; +static const char __pyx_k_addBendersSubproblem[] = "addBendersSubproblem"; +static const char __pyx_k_chgVarBranchPriority[] = "chgVarBranchPriority"; +static const char __pyx_k_createEmptyRowUnspec[] = "createEmptyRowUnspec"; +static const char __pyx_k_enableReoptimization[] = "enableReoptimization"; +static const char __pyx_k_getBendersSubproblem[] = "getBendersSubproblem"; +static const char __pyx_k_getNInfeasibleLeaves[] = "getNInfeasibleLeaves"; +static const char __pyx_k_getNParentBranchings[] = "getNParentBranchings"; +static const char __pyx_k_getPseudoBranchCands[] = "getPseudoBranchCands"; +static const char __pyx_k_getRowObjParallelism[] = "getRowObjParallelism"; +static const char __pyx_k_getSlackVarIndicator[] = "getSlackVarIndicator"; +static const char __pyx_k_pyx_unpickle_GenExpr[] = "__pyx_unpickle_GenExpr"; +static const char __pyx_k_pyx_unpickle_Nodesel[] = "__pyx_unpickle_Nodesel"; +static const char __pyx_k_pyx_unpickle_PowExpr[] = "__pyx_unpickle_PowExpr"; +static const char __pyx_k_pyx_unpickle_SumExpr[] = "__pyx_unpickle_SumExpr"; +static const char __pyx_k_pyx_unpickle_VarExpr[] = "__pyx_unpickle_VarExpr"; +static const char __pyx_k_repr___locals_lambda[] = "__repr__.."; +static const char __pyx_k_src_pyscipopt_lp_pxi[] = "src/pyscipopt/lp.pxi"; +static const char __pyx_k_updateNodeLowerbound[] = "updateNodeLowerbound"; +static const char __pyx_k_Benders_bendersgetvar[] = "Benders.bendersgetvar"; +static const char __pyx_k_Branchrule_branchexit[] = "Branchrule.branchexit"; +static const char __pyx_k_Branchrule_branchfree[] = "Branchrule.branchfree"; +static const char __pyx_k_Branchrule_branchinit[] = "Branchrule.branchinit"; +static const char __pyx_k_Column_getBasisStatus[] = "Column.getBasisStatus"; +static const char __pyx_k_Conshdlr_consdeactive[] = "Conshdlr.consdeactive"; +static const char __pyx_k_Conshdlr_consgetnvars[] = "Conshdlr.consgetnvars"; +static const char __pyx_k_Constraint_isEnforced[] = "Constraint.isEnforced"; +static const char __pyx_k_Constraint_isOriginal[] = "Constraint.isOriginal"; +static const char __pyx_k_Event___reduce_cython[] = "Event.__reduce_cython__"; +static const char __pyx_k_Eventhdlr_eventdelete[] = "Eventhdlr.eventdelete"; +static const char __pyx_k_Model___reduce_cython[] = "Model.__reduce_cython__"; +static const char __pyx_k_Model_activateBenders[] = "Model.activateBenders"; +static const char __pyx_k_Model_chgVarLbProbing[] = "Model.chgVarLbProbing"; +static const char __pyx_k_Model_chgVarUbProbing[] = "Model.chgVarUbProbing"; +static const char __pyx_k_Model_createProbBasic[] = "Model.createProbBasic"; +static const char __pyx_k_Model_getNCountedSols[] = "Model.getNCountedSols"; +static const char __pyx_k_Model_getNCutsApplied[] = "Model.getNCutsApplied"; +static const char __pyx_k_Model_getPrimalRayVal[] = "Model.getPrimalRayVal"; +static const char __pyx_k_Model_getProbingDepth[] = "Model.getProbingDepth"; +static const char __pyx_k_Model_inRepropagation[] = "Model.inRepropagation"; +static const char __pyx_k_Model_includeConshdlr[] = "Model.includeConshdlr"; +static const char __pyx_k_Model_printStatistics[] = "Model.printStatistics"; +static const char __pyx_k_Model_repropagateNode[] = "Model.repropagateNode"; +static const char __pyx_k_Model_setLongintParam[] = "Model.setLongintParam"; +static const char __pyx_k_Model_solveConcurrent[] = "Model.solveConcurrent"; +static const char __pyx_k_Model_writeStatistics[] = "Model.writeStatistics"; +static const char __pyx_k_NLRow___reduce_cython[] = "NLRow.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_PARAMEMPHASIS[] = "PY_SCIP_PARAMEMPHASIS"; +static const char __pyx_k_PY_SCIP_ROWORIGINTYPE[] = "PY_SCIP_ROWORIGINTYPE"; +static const char __pyx_k_Relax___reduce_cython[] = "Relax.__reduce_cython__"; +static const char __pyx_k_Row___setstate_cython[] = "Row.__setstate_cython__"; +static const char __pyx_k_Row_isInGlobalCutpool[] = "Row.isInGlobalCutpool"; +static const char __pyx_k_benderssolvesubconvex[] = "benderssolvesubconvex"; +static const char __pyx_k_degree_locals_genexpr[] = "degree..genexpr"; +static const char __pyx_k_getTreesizeEstimation[] = "getTreesizeEstimation"; +static const char __pyx_k_includeDefaultPlugins[] = "includeDefaultPlugins"; +static const char __pyx_k_propagating_maxrounds[] = "propagating/maxrounds"; +static const char __pyx_k_pyx_unpickle_Conshdlr[] = "__pyx_unpickle_Conshdlr"; +static const char __pyx_k_pyx_unpickle_Constant[] = "__pyx_unpickle_Constant"; +static const char __pyx_k_pyx_unpickle_ExprCons[] = "__pyx_unpickle_ExprCons"; +static const char __pyx_k_pyx_unpickle_ProdExpr[] = "__pyx_unpickle_ProdExpr"; +static const char __pyx_k_wrote_problem_to_file[] = "wrote problem to file "; +static const char __pyx_k_Benders_bendersexitpre[] = "Benders.bendersexitpre"; +static const char __pyx_k_Benders_bendersexitsol[] = "Benders.bendersexitsol"; +static const char __pyx_k_Benders_bendersfreesub[] = "Benders.bendersfreesub"; +static const char __pyx_k_Benders_bendersinitpre[] = "Benders.bendersinitpre"; +static const char __pyx_k_Benders_bendersinitsol[] = "Benders.bendersinitsol"; +static const char __pyx_k_Column___reduce_cython[] = "Column.__reduce_cython__"; +static const char __pyx_k_Conshdlr_consenforelax[] = "Conshdlr.consenforelax"; +static const char __pyx_k_Constraint_isNonlinear[] = "Constraint.isNonlinear"; +static const char __pyx_k_Constraint_isRemovable[] = "Constraint.isRemovable"; +static const char __pyx_k_Constraint_isSeparated[] = "Constraint.isSeparated"; +static const char __pyx_k_Cutsel___reduce_cython[] = "Cutsel.__reduce_cython__"; +static const char __pyx_k_Eventhdlr_eventexitsol[] = "Eventhdlr.eventexitsol"; +static const char __pyx_k_Eventhdlr_eventinitsol[] = "Eventhdlr.eventinitsol"; +static const char __pyx_k_Expr___setstate_cython[] = "Expr.__setstate_cython__"; +static const char __pyx_k_Heur___setstate_cython[] = "Heur.__setstate_cython__"; +static const char __pyx_k_Model_addConsIndicator[] = "Model.addConsIndicator"; +static const char __pyx_k_Model_addExprNonlinear[] = "Model.addExprNonlinear"; +static const char __pyx_k_Model_applyCutsProbing[] = "Model.applyCutsProbing"; +static const char __pyx_k_Model_backtrackProbing[] = "Model.backtrackProbing"; +static const char __pyx_k_Model_chgVarObjProbing[] = "Model.chgVarObjProbing"; +static const char __pyx_k_Model_createPartialSol[] = "Model.createPartialSol"; +static const char __pyx_k_Model_getBestboundNode[] = "Model.getBestboundNode"; +static const char __pyx_k_Model_getDualboundRoot[] = "Model.getDualboundRoot"; +static const char __pyx_k_Model_getDualsolLinear[] = "Model.getDualsolLinear"; +static const char __pyx_k_Model_getLPBranchCands[] = "Model.getLPBranchCands"; +static const char __pyx_k_Model_getLocalEstimate[] = "Model.getLocalEstimate"; +static const char __pyx_k_Model_getNLPIterations[] = "Model.getNLPIterations"; +static const char __pyx_k_Model_getNLimSolsFound[] = "Model.getNLimSolsFound"; +static const char __pyx_k_Model_getRowLPActivity[] = "Model.getRowLPActivity"; +static const char __pyx_k_Model_getRowNumIntCols[] = "Model.getRowNumIntCols"; +static const char __pyx_k_Model_includeEventhdlr[] = "Model.includeEventhdlr"; +static const char __pyx_k_Model_isCutEfficacious[] = "Model.isCutEfficacious"; +static const char __pyx_k_Model_isNLPConstructed[] = "Model.isNLPConstructed"; +static const char __pyx_k_Model_lpiGetIterations[] = "Model.lpiGetIterations"; +static const char __pyx_k_Model_propagateProbing[] = "Model.propagateProbing"; +static const char __pyx_k_Node___setstate_cython[] = "Node.__setstate_cython__"; +static const char __pyx_k_Node_isPropagatedAgain[] = "Node.isPropagatedAgain"; +static const char __pyx_k_Presol___reduce_cython[] = "Presol.__reduce_cython__"; +static const char __pyx_k_Pricer___reduce_cython[] = "Pricer.__reduce_cython__"; +static const char __pyx_k_Prop___setstate_cython[] = "Prop.__setstate_cython__"; +static const char __pyx_k_Reader___reduce_cython[] = "Reader.__reduce_cython__"; +static const char __pyx_k_SCIP_no_problem_exists[] = "SCIP: no problem exists!"; +static const char __pyx_k_SCIP_unspecified_error[] = "SCIP: unspecified error!"; +static const char __pyx_k_Sepa___setstate_cython[] = "Sepa.__setstate_cython__"; +static const char __pyx_k_Variable_getLbOriginal[] = "Variable.getLbOriginal"; +static const char __pyx_k_Variable_getUbOriginal[] = "Variable.getUbOriginal"; +static const char __pyx_k_addCols_locals_genexpr[] = "addCols..genexpr"; +static const char __pyx_k_addConsElemDisjunction[] = "addConsElemDisjunction"; +static const char __pyx_k_addRows_locals_genexpr[] = "addRows..genexpr"; +static const char __pyx_k_createConsGenNonlinear[] = "_createConsGenNonlinear"; +static const char __pyx_k_freeBendersSubproblems[] = "freeBendersSubproblems"; +static const char __pyx_k_getBendersAuxiliaryVar[] = "getBendersAuxiliaryVar"; +static const char __pyx_k_getNlRowActivityBounds[] = "getNlRowActivityBounds"; +static const char __pyx_k_getNlRowSolFeasibility[] = "getNlRowSolFeasibility"; +static const char __pyx_k_pyx_unpickle_Eventhdlr[] = "__pyx_unpickle_Eventhdlr"; +static const char __pyx_k_pyx_unpickle_UnaryExpr[] = "__pyx_unpickle_UnaryExpr"; +static const char __pyx_k_setupBendersSubproblem[] = "setupBendersSubproblem"; +static const char __pyx_k_solveBendersSubproblem[] = "solveBendersSubproblem"; +static const char __pyx_k_src_pyscipopt_expr_pxi[] = "src/pyscipopt/expr.pxi"; +static const char __pyx_k_src_pyscipopt_scip_pxi[] = "src/pyscipopt/scip.pxi"; +static const char __pyx_k_src_pyscipopt_sepa_pxi[] = "src/pyscipopt/sepa.pxi"; +static const char __pyx_k_Benders___reduce_cython[] = "Benders.__reduce_cython__"; +static const char __pyx_k_Benders_benderssolvesub[] = "Benders.benderssolvesub"; +static const char __pyx_k_BoundChange_getNewBound[] = "BoundChange.getNewBound"; +static const char __pyx_k_BoundChange_isRedundant[] = "BoundChange.isRedundant"; +static const char __pyx_k_Branchrule_branchexeclp[] = "Branchrule.branchexeclp"; +static const char __pyx_k_Branchrule_branchexecps[] = "Branchrule.branchexecps"; +static const char __pyx_k_Constraint_isModifiable[] = "Constraint.isModifiable"; +static const char __pyx_k_Constraint_isPropagated[] = "Constraint.isPropagated"; +static const char __pyx_k_Event___setstate_cython[] = "Event.__setstate_cython__"; +static const char __pyx_k_GenExpr___reduce_cython[] = "GenExpr.__reduce_cython__"; +static const char __pyx_k_Model___setstate_cython[] = "Model.__setstate_cython__"; +static const char __pyx_k_Model__createConsLinear[] = "Model._createConsLinear"; +static const char __pyx_k_Model_calcChildEstimate[] = "Model.calcChildEstimate"; +static const char __pyx_k_Model_chgReoptObjective[] = "Model.chgReoptObjective"; +static const char __pyx_k_Model_getDualMultiplier[] = "Model.getDualMultiplier"; +static const char __pyx_k_Model_getNBestSolsFound[] = "Model.getNBestSolsFound"; +static const char __pyx_k_Model_getObjectiveSense[] = "Model.getObjectiveSense"; +static const char __pyx_k_Model_getPresolvingTime[] = "Model.getPresolvingTime"; +static const char __pyx_k_Model_getRowParallelism[] = "Model.getRowParallelism"; +static const char __pyx_k_Model_getTermsQuadratic[] = "Model.getTermsQuadratic"; +static const char __pyx_k_Model_getTransformedVar[] = "Model.getTransformedVar"; +static const char __pyx_k_Model_includeBenderscut[] = "Model.includeBenderscut"; +static const char __pyx_k_Model_includeBranchrule[] = "Model.includeBranchrule"; +static const char __pyx_k_Model_writeBestTransSol[] = "Model.writeBestTransSol"; +static const char __pyx_k_NLRow___setstate_cython[] = "NLRow.__setstate_cython__"; +static const char __pyx_k_Nodesel___reduce_cython[] = "Nodesel.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_BENDERSENFOTYPE[] = "PY_SCIP_BENDERSENFOTYPE"; +static const char __pyx_k_PowExpr___reduce_cython[] = "PowExpr.__reduce_cython__"; +static const char __pyx_k_Relax___setstate_cython[] = "Relax.__setstate_cython__"; +static const char __pyx_k_SCIP_cannot_create_file[] = "SCIP: cannot create file!"; +static const char __pyx_k_SCIP_error_in_LP_solver[] = "SCIP: error in LP solver!"; +static const char __pyx_k_SumExpr___reduce_cython[] = "SumExpr.__reduce_cython__"; +static const char __pyx_k_This_is_a_monomial_term[] = "This is a monomial term"; +static const char __pyx_k_VarExpr___reduce_cython[] = "VarExpr.__reduce_cython__"; +static const char __pyx_k_checkQuadraticNonlinear[] = "checkQuadraticNonlinear"; +static const char __pyx_k_event_handler_not_found[] = "event handler not found"; +static const char __pyx_k_pyx_unpickle_Benderscut[] = "__pyx_unpickle_Benderscut"; +static const char __pyx_k_pyx_unpickle_Branchrule[] = "__pyx_unpickle_Branchrule"; +static const char __pyx_k_src_pyscipopt_event_pxi[] = "src/pyscipopt/event.pxi"; +static const char __pyx_k_src_pyscipopt_relax_pxi[] = "src/pyscipopt/relax.pxi"; +static const char __pyx_k_Benders_benderscreatesub[] = "Benders.benderscreatesub"; +static const char __pyx_k_Benders_benderspostsolve[] = "Benders.benderspostsolve"; +static const char __pyx_k_BoundChange_getBoundtype[] = "BoundChange.getBoundtype"; +static const char __pyx_k_Branchrule_branchexecext[] = "Branchrule.branchexecext"; +static const char __pyx_k_Branchrule_branchexitsol[] = "Branchrule.branchexitsol"; +static const char __pyx_k_Branchrule_branchinitsol[] = "Branchrule.branchinitsol"; +static const char __pyx_k_Column___setstate_cython[] = "Column.__setstate_cython__"; +static const char __pyx_k_Conshdlr___reduce_cython[] = "Conshdlr.__reduce_cython__"; +static const char __pyx_k_Constant___reduce_cython[] = "Constant.__reduce_cython__"; +static const char __pyx_k_Cutsel___setstate_cython[] = "Cutsel.__setstate_cython__"; +static const char __pyx_k_ExprCons___reduce_cython[] = "ExprCons.__reduce_cython__"; +static const char __pyx_k_Model_addConsCardinality[] = "Model.addConsCardinality"; +static const char __pyx_k_Model_addConsDisjunction[] = "Model.addConsDisjunction"; +static const char __pyx_k_Model_cacheRowExtensions[] = "Model.cacheRowExtensions"; +static const char __pyx_k_Model_createConsFromExpr[] = "Model.createConsFromExpr"; +static const char __pyx_k_Model_createEmptyRowSepa[] = "Model.createEmptyRowSepa"; +static const char __pyx_k_Model_disablePropagation[] = "Model.disablePropagation"; +static const char __pyx_k_Model_flushRowExtensions[] = "Model.flushRowExtensions"; +static const char __pyx_k_Model_getNFeasibleLeaves[] = "Model.getNFeasibleLeaves"; +static const char __pyx_k_Model_getTransformedCons[] = "Model.getTransformedCons"; +static const char __pyx_k_Model_initBendersDefault[] = "Model.initBendersDefault"; +static const char __pyx_k_Model_setParamsCountsols[] = "Model.setParamsCountsols"; +static const char __pyx_k_Model_tightenVarLbGlobal[] = "Model.tightenVarLbGlobal"; +static const char __pyx_k_Model_tightenVarUbGlobal[] = "Model.tightenVarUbGlobal"; +static const char __pyx_k_Node_getParentBranchings[] = "Node.getParentBranchings"; +static const char __pyx_k_Presol___setstate_cython[] = "Presol.__setstate_cython__"; +static const char __pyx_k_Pricer___setstate_cython[] = "Pricer.__setstate_cython__"; +static const char __pyx_k_ProdExpr___reduce_cython[] = "ProdExpr.__reduce_cython__"; +static const char __pyx_k_Reader___setstate_cython[] = "Reader.__setstate_cython__"; +static const char __pyx_k_SCIP_BOUNDTYPE_TO_STRING[] = "_SCIP_BOUNDTYPE_TO_STRING"; +static const char __pyx_k_SCIP_error_in_input_data[] = "SCIP: error in input data!"; +static const char __pyx_k_SCIP_unknown_return_code[] = "SCIP: unknown return code!"; +static const char __pyx_k_Solution___reduce_cython[] = "Solution.__reduce_cython__"; +static const char __pyx_k_Variable___reduce_cython[] = "Variable.__reduce_cython__"; +static const char __pyx_k_getitem___locals_genexpr[] = "__getitem__..genexpr"; +static const char __pyx_k_src_pyscipopt_cutsel_pxi[] = "src/pyscipopt/cutsel.pxi"; +static const char __pyx_k_src_pyscipopt_presol_pxi[] = "src/pyscipopt/presol.pxi"; +static const char __pyx_k_src_pyscipopt_pricer_pxi[] = "src/pyscipopt/pricer.pxi"; +static const char __pyx_k_src_pyscipopt_reader_pxi[] = "src/pyscipopt/reader.pxi"; +static const char __pyx_k_updateBendersLowerbounds[] = "updateBendersLowerbounds"; +static const char __pyx_k_Benders___setstate_cython[] = "Benders.__setstate_cython__"; +static const char __pyx_k_Benderscut_benderscutexec[] = "Benderscut.benderscutexec"; +static const char __pyx_k_Benderscut_benderscutexit[] = "Benderscut.benderscutexit"; +static const char __pyx_k_Benderscut_benderscutfree[] = "Benderscut.benderscutfree"; +static const char __pyx_k_Benderscut_benderscutinit[] = "Benderscut.benderscutinit"; +static const char __pyx_k_Eventhdlr___reduce_cython[] = "Eventhdlr.__reduce_cython__"; +static const char __pyx_k_GenExpr___setstate_cython[] = "GenExpr.__setstate_cython__"; +static const char __pyx_k_Model_calcNodeselPriority[] = "Model.calcNodeselPriority"; +static const char __pyx_k_Model_getDualfarkasLinear[] = "Model.getDualfarkasLinear"; +static const char __pyx_k_Model_getNlRowSolActivity[] = "Model.getNlRowSolActivity"; +static const char __pyx_k_Model_isObjChangedProbing[] = "Model.isObjChangedProbing"; +static const char __pyx_k_Node_getNParentBranchings[] = "Node.getNParentBranchings"; +static const char __pyx_k_Nodesel___setstate_cython[] = "Nodesel.__setstate_cython__"; +static const char __pyx_k_PowExpr___setstate_cython[] = "PowExpr.__setstate_cython__"; +static const char __pyx_k_SCIP_file_not_found_error[] = "SCIP: file not found error!"; +static const char __pyx_k_SumExpr___setstate_cython[] = "SumExpr.__setstate_cython__"; +static const char __pyx_k_UnaryExpr___reduce_cython[] = "UnaryExpr.__reduce_cython__"; +static const char __pyx_k_VarExpr___setstate_cython[] = "VarExpr.__setstate_cython__"; +static const char __pyx_k_computeBestSolSubproblems[] = "computeBestSolSubproblems"; +static const char __pyx_k_consgetsignedpermsymgraph[] = "consgetsignedpermsymgraph"; +static const char __pyx_k_exponents_must_be_numbers[] = "exponents must be numbers"; +static const char __pyx_k_getConsOriginConshdlrtype[] = "getConsOriginConshdlrtype"; +static const char __pyx_k_getCutLPSolCutoffDistance[] = "getCutLPSolCutoffDistance"; +static const char __pyx_k_includeBendersDefaultCuts[] = "includeBendersDefaultCuts"; +static const char __pyx_k_printExternalCodeVersions[] = "printExternalCodeVersions"; +static const char __pyx_k_propagating_maxroundsroot[] = "propagating/maxroundsroot"; +static const char __pyx_k_src_pyscipopt_benders_pxi[] = "src/pyscipopt/benders.pxi"; +static const char __pyx_k_src_pyscipopt_nodesel_pxi[] = "src/pyscipopt/nodesel.pxi"; +static const char __pyx_k_Benders_benderspresubsolve[] = "Benders.benderspresubsolve"; +static const char __pyx_k_Benderscut___reduce_cython[] = "Benderscut.__reduce_cython__"; +static const char __pyx_k_Branchrule___reduce_cython[] = "Branchrule.__reduce_cython__"; +static const char __pyx_k_Conshdlr___setstate_cython[] = "Conshdlr.__setstate_cython__"; +static const char __pyx_k_Conshdlr_consgetdivebdchgs[] = "Conshdlr.consgetdivebdchgs"; +static const char __pyx_k_Constant___setstate_cython[] = "Constant.__setstate_cython__"; +static const char __pyx_k_Constraint___reduce_cython[] = "Constraint.__reduce_cython__"; +static const char __pyx_k_Constraint_getConshdlrName[] = "Constraint.getConshdlrName"; +static const char __pyx_k_DomainChanges_getBoundchgs[] = "DomainChanges.getBoundchgs"; +static const char __pyx_k_ExprCons___setstate_cython[] = "ExprCons.__setstate_cython__"; +static const char __pyx_k_Model__createConsNonlinear[] = "Model._createConsNonlinear"; +static const char __pyx_k_Model__createConsQuadratic[] = "Model._createConsQuadratic"; +static const char __pyx_k_Model_addBendersSubproblem[] = "Model.addBendersSubproblem"; +static const char __pyx_k_Model_chgVarBranchPriority[] = "Model.chgVarBranchPriority"; +static const char __pyx_k_Model_createEmptyRowUnspec[] = "Model.createEmptyRowUnspec"; +static const char __pyx_k_Model_enableReoptimization[] = "Model.enableReoptimization"; +static const char __pyx_k_Model_getBendersSubproblem[] = "Model.getBendersSubproblem"; +static const char __pyx_k_Model_getNInfeasibleLeaves[] = "Model.getNInfeasibleLeaves"; +static const char __pyx_k_Model_getPseudoBranchCands[] = "Model.getPseudoBranchCands"; +static const char __pyx_k_Model_getRowObjParallelism[] = "Model.getRowObjParallelism"; +static const char __pyx_k_Model_getSlackVarIndicator[] = "Model.getSlackVarIndicator"; +static const char __pyx_k_Model_updateNodeLowerbound[] = "Model.updateNodeLowerbound"; +static const char __pyx_k_Not_a_valid_parameter_name[] = "Not a valid parameter name"; +static const char __pyx_k_ProdExpr___setstate_cython[] = "ProdExpr.__setstate_cython__"; +static const char __pyx_k_Solution___setstate_cython[] = "Solution.__setstate_cython__"; +static const char __pyx_k_Variable___setstate_cython[] = "Variable.__setstate_cython__"; +static const char __pyx_k_constraints_benders_active[] = "constraints/benders/active"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_STAGE[] = "__pyx_unpickle_PY_SCIP_STAGE"; +static const char __pyx_k_src_pyscipopt_conshdlr_pxi[] = "src/pyscipopt/conshdlr.pxi"; +static const char __pyx_k_unrecognized_variable_type[] = "unrecognized variable type"; +static const char __pyx_k_BoundChange___reduce_cython[] = "BoundChange.__reduce_cython__"; +static const char __pyx_k_BoundChange_getBoundchgtype[] = "BoundChange.getBoundchgtype"; +static const char __pyx_k_Constraint_isStickingAtNode[] = "Constraint.isStickingAtNode"; +static const char __pyx_k_Eventhdlr___setstate_cython[] = "Eventhdlr.__setstate_cython__"; +static const char __pyx_k_Model_getTreesizeEstimation[] = "Model.getTreesizeEstimation"; +static const char __pyx_k_Model_includeDefaultPlugins[] = "Model.includeDefaultPlugins"; +static const char __pyx_k_Term___init___locals_lambda[] = "Term.__init__.."; +static const char __pyx_k_UnaryExpr___setstate_cython[] = "UnaryExpr.__setstate_cython__"; +static const char __pyx_k_constraint_is_not_nonlinear[] = "constraint is not nonlinear"; +static const char __pyx_k_constraint_is_not_quadratic[] = "constraint is not quadratic"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_RESULT[] = "__pyx_unpickle_PY_SCIP_RESULT"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_STATUS[] = "__pyx_unpickle_PY_SCIP_STATUS"; +static const char __pyx_k_src_pyscipopt_heuristic_pxi[] = "src/pyscipopt/heuristic.pxi"; +static const char __pyx_k_Benderscut___setstate_cython[] = "Benderscut.__setstate_cython__"; +static const char __pyx_k_Benderscut_benderscutexitsol[] = "Benderscut.benderscutexitsol"; +static const char __pyx_k_Benderscut_benderscutinitsol[] = "Benderscut.benderscutinitsol"; +static const char __pyx_k_Branchrule___setstate_cython[] = "Branchrule.__setstate_cython__"; +static const char __pyx_k_Conshdlr_consgetpermsymgraph[] = "Conshdlr.consgetpermsymgraph"; +static const char __pyx_k_Constraint___setstate_cython[] = "Constraint.__setstate_cython__"; +static const char __pyx_k_Model_addConsElemDisjunction[] = "Model.addConsElemDisjunction"; +static const char __pyx_k_Model_freeBendersSubproblems[] = "Model.freeBendersSubproblems"; +static const char __pyx_k_Model_getBendersAuxiliaryVar[] = "Model.getBendersAuxiliaryVar"; +static const char __pyx_k_Model_getNlRowActivityBounds[] = "Model.getNlRowActivityBounds"; +static const char __pyx_k_Model_getNlRowSolFeasibility[] = "Model.getNlRowSolFeasibility"; +static const char __pyx_k_Model_setupBendersSubproblem[] = "Model.setupBendersSubproblem"; +static const char __pyx_k_Model_solveBendersSubproblem[] = "Model.solveBendersSubproblem"; +static const char __pyx_k_Term___init___locals_genexpr[] = "Term.__init__..genexpr"; +static const char __pyx_k_constraints_benderslp_active[] = "constraints/benderslp/active"; +static const char __pyx_k_setBendersSubproblemIsConvex[] = "setBendersSubproblemIsConvex"; +static const char __pyx_k_src_pyscipopt_benderscut_pxi[] = "src/pyscipopt/benderscut.pxi"; +static const char __pyx_k_src_pyscipopt_branchrule_pxi[] = "src/pyscipopt/branchrule.pxi"; +static const char __pyx_k_src_pyscipopt_propagator_pxi[] = "src/pyscipopt/propagator.pxi"; +static const char __pyx_k_unrecognized_objective_sense[] = "unrecognized objective sense"; +static const char __pyx_k_Benders_benderssolvesubconvex[] = "Benders.benderssolvesubconvex"; +static const char __pyx_k_BoundChange___setstate_cython[] = "BoundChange.__setstate_cython__"; +static const char __pyx_k_DomainChanges___reduce_cython[] = "DomainChanges.__reduce_cython__"; +static const char __pyx_k_Model__createConsGenNonlinear[] = "Model._createConsGenNonlinear"; +static const char __pyx_k_Model_checkQuadraticNonlinear[] = "Model.checkQuadraticNonlinear"; +static const char __pyx_k_PY_SCIP_STAGE___reduce_cython[] = "PY_SCIP_STAGE.__reduce_cython__"; +static const char __pyx_k_Row_getConsOriginConshdlrtype[] = "Row.getConsOriginConshdlrtype"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_NODETYPE[] = "__pyx_unpickle_PY_SCIP_NODETYPE"; +static const char __pyx_k_Model_updateBendersLowerbounds[] = "Model.updateBendersLowerbounds"; +static const char __pyx_k_PY_SCIP_RESULT___reduce_cython[] = "PY_SCIP_RESULT.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_STATUS___reduce_cython[] = "PY_SCIP_STATUS.__reduce_cython__"; +static const char __pyx_k_SCIP_insufficient_memory_error[] = "SCIP: insufficient memory error!"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_BENDERSEN[] = "__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_BRANCHDIR[] = "__pyx_unpickle_PY_SCIP_BRANCHDIR"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_EVENTTYPE[] = "__pyx_unpickle_PY_SCIP_EVENTTYPE"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_HEURTIMIN[] = "__pyx_unpickle_PY_SCIP_HEURTIMING"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_LPSOLSTAT[] = "__pyx_unpickle_PY_SCIP_LPSOLSTAT"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_PARAMEMPH[] = "__pyx_unpickle_PY_SCIP_PARAMEMPHASIS"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_PARAMSETT[] = "__pyx_unpickle_PY_SCIP_PARAMSETTING"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_PRESOLTIM[] = "__pyx_unpickle_PY_SCIP_PRESOLTIMING"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_PROPTIMIN[] = "__pyx_unpickle_PY_SCIP_PROPTIMING"; +static const char __pyx_k_pyx_unpickle_PY_SCIP_ROWORIGIN[] = "__pyx_unpickle_PY_SCIP_ROWORIGINTYPE"; +static const char __pyx_k_DomainChanges___setstate_cython[] = "DomainChanges.__setstate_cython__"; +static const char __pyx_k_Model_computeBestSolSubproblems[] = "Model.computeBestSolSubproblems"; +static const char __pyx_k_Model_getCutLPSolCutoffDistance[] = "Model.getCutLPSolCutoffDistance"; +static const char __pyx_k_Model_includeBendersDefaultCuts[] = "Model.includeBendersDefaultCuts"; +static const char __pyx_k_Model_printExternalCodeVersions[] = "Model.printExternalCodeVersions"; +static const char __pyx_k_PY_SCIP_PARAMSETTING___setstate[] = "PY_SCIP_PARAMSETTING.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_PRESOLTIMING___setstate[] = "PY_SCIP_PRESOLTIMING.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_STAGE___setstate_cython[] = "PY_SCIP_STAGE.__setstate_cython__"; +static const char __pyx_k_Provide_BOOLEAN_value_as_rhsvar[] = "Provide BOOLEAN value as rhsvar, you gave %s."; +static const char __pyx_k_SCIP_does_not_support_nonlinear[] = "SCIP does not support nonlinear objective functions. Consider using set_nonlinear_objective in the pyscipopt.recipe.nonlinear"; +static const char __pyx_k_SCIP_method_cannot_be_called_at[] = "SCIP: method cannot be called at this time in solution process!"; +static const char __pyx_k_SCIP_method_returned_an_invalid[] = "SCIP: method returned an invalid result code!"; +static const char __pyx_k_SCIP_reading_solution_from_file[] = "SCIP: reading solution from file "; +static const char __pyx_k_To_create_a_solution_you_should[] = "To create a solution you should use the createSol method of the Model class."; +static const char __pyx_k_addConss_locals_ensure_iterable[] = "addConss..ensure_iterable"; +static const char __pyx_k_can_only_be_called_with_a_valid[] = " can only be called with a valid solution or in stage SOLVING (current stage: "; +static const char __pyx_k_cannot_create_Row_with_SCIP_ROW[] = "cannot create Row with SCIP_ROW* == NULL"; +static const char __pyx_k_given_coefficients_are_not_Expr[] = "given coefficients are not Expr but %s"; +static const char __pyx_k_model_getDualMultiplier_cons_is[] = "model.getDualMultiplier(cons) is deprecated: please use model.getDualsolLinear(cons)"; +static const char __pyx_k_python_error_in_consenfolp_this[] = "python error in consenfolp: this method needs to be implemented"; +static const char __pyx_k_python_error_in_consenfops_this[] = "python error in consenfops: this method needs to be implemented"; +static const char __pyx_k_python_error_in_presolexec_this[] = "python error in presolexec: this method needs to be implemented"; +static const char __pyx_k_self_lpi_cannot_be_converted_to[] = "self.lpi cannot be converted to a Python object for pickling"; +static const char __pyx_k_total_number_of_solutions_found[] = "total number of solutions found is not valid!"; +static const char __pyx_k_unrecognized_optimization_sense[] = "unrecognized optimization sense: %s"; +static const char __pyx_k_Can_only_support_constraints_wit[] = "Can only support constraints with '<=', '>=', or '=='."; +static const char __pyx_k_Can_t_evaluate_constraints_as_bo[] = "Can't evaluate constraints as booleans.\n\nIf you want to add a ranged constraint of the form\n lhs <= expression <= rhs\nyou have to use parenthesis to break the Python syntax for chained comparisons:\n lhs <= (expression <= rhs)\n"; +static const char __pyx_k_Cannot_set_value_to_a_freed_solu[] = "Cannot set value to a freed solution."; +static const char __pyx_k_Conshdlr_consgetsignedpermsymgra[] = "Conshdlr.consgetsignedpermsymgraph"; +static const char __pyx_k_Constant_offsets_in_objective_ar[] = "Constant offsets in objective are not supported!"; +static const char __pyx_k_ExprCons_already_has_lower_bound[] = "ExprCons already has lower bound"; +static const char __pyx_k_ExprCons_already_has_upper_bound[] = "ExprCons already has upper bound"; +static const char __pyx_k_Given_constraint_list_is_not_ite[] = "Given constraint list is not iterable."; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))"; +static const char __pyx_k_Model_checkBendersSubproblemOpti[] = "Model.checkBendersSubproblemOptimality"; +static const char __pyx_k_Model_setBendersSubproblemIsConv[] = "Model.setBendersSubproblemIsConvex"; +static const char __pyx_k_Nonlinear_objective_functions_ar[] = "Nonlinear objective functions are not supported!"; +static const char __pyx_k_PY_SCIP_BENDERSENFOTYPE___reduce[] = "PY_SCIP_BENDERSENFOTYPE.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_BENDERSENFOTYPE___setsta[] = "PY_SCIP_BENDERSENFOTYPE.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_BRANCHDIR___reduce_cytho[] = "PY_SCIP_BRANCHDIR.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_BRANCHDIR___setstate_cyt[] = "PY_SCIP_BRANCHDIR.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_EVENTTYPE___reduce_cytho[] = "PY_SCIP_EVENTTYPE.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_EVENTTYPE___setstate_cyt[] = "PY_SCIP_EVENTTYPE.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_HEURTIMING___reduce_cyth[] = "PY_SCIP_HEURTIMING.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_HEURTIMING___setstate_cy[] = "PY_SCIP_HEURTIMING.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_LPSOLSTAT___reduce_cytho[] = "PY_SCIP_LPSOLSTAT.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_LPSOLSTAT___setstate_cyt[] = "PY_SCIP_LPSOLSTAT.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_NODETYPE___reduce_cython[] = "PY_SCIP_NODETYPE.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_NODETYPE___setstate_cyth[] = "PY_SCIP_NODETYPE.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_PARAMEMPHASIS___reduce_c[] = "PY_SCIP_PARAMEMPHASIS.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_PARAMEMPHASIS___setstate[] = "PY_SCIP_PARAMEMPHASIS.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_PARAMSETTING___reduce_cy[] = "PY_SCIP_PARAMSETTING.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_PRESOLTIMING___reduce_cy[] = "PY_SCIP_PRESOLTIMING.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_PROPTIMING___reduce_cyth[] = "PY_SCIP_PROPTIMING.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_PROPTIMING___setstate_cy[] = "PY_SCIP_PROPTIMING.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_RESULT___setstate_cython[] = "PY_SCIP_RESULT.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_ROWORIGINTYPE___reduce_c[] = "PY_SCIP_ROWORIGINTYPE.__reduce_cython__"; +static const char __pyx_k_PY_SCIP_ROWORIGINTYPE___setstate[] = "PY_SCIP_ROWORIGINTYPE.__setstate_cython__"; +static const char __pyx_k_PY_SCIP_STATUS___setstate_cython[] = "PY_SCIP_STATUS.__setstate_cython__"; +static const char __pyx_k_Ranged_ExprCons_is_not_well_defi[] = "Ranged ExprCons is not well defined!"; +static const char __pyx_k_SCIP_a_required_plugin_was_not_f[] = "SCIP: a required plugin was not found !"; +static const char __pyx_k_SCIP_maximal_branching_depth_lev[] = "SCIP: maximal branching depth level exceeded!"; +static const char __pyx_k_SCIP_returned_base_status_zero_f[] = "SCIP returned base status zero for a row!"; +static const char __pyx_k_SCIP_returned_unknown_base_statu[] = "SCIP returned unknown base status!"; +static const char __pyx_k_SCIP_the_given_key_is_already_ex[] = "SCIP: the given key is already existing in table!"; +static const char __pyx_k_SCIP_the_parameter_is_not_of_the[] = "SCIP: the parameter is not of the expected type!"; +static const char __pyx_k_SCIP_the_parameter_with_the_give[] = "SCIP: the parameter with the given name was not found!"; +static const char __pyx_k_SCIP_the_value_is_invalid_for_th[] = "SCIP: the value is invalid for the given parameter!"; +static const char __pyx_k_SCIP_was_compiled_without_task_p[] = "SCIP was compiled without task processing interface. Parallel solve not possible - using optimize() instead of solveConcurrent()"; +static const char __pyx_k_The_constraint_handler_s_does_no[] = "The constraint handler %s does not have this functionality."; +static const char __pyx_k_The_given_capsule_does_not_conta[] = "The given capsule does not contain a valid scip pointer"; +static const char __pyx_k_The_given_variable_is_not_a_pyva[] = "The given variable is not a pyvar, but %s"; +static const char __pyx_k_The_problem_does_not_have_a_prim[] = "The problem does not have a primal ray."; +static const char __pyx_k_addConsDisjunction_locals_ensure[] = "addConsDisjunction..ensure_iterable"; +static const char __pyx_k_addExprNonlinear_can_only_be_cal[] = "addExprNonlinear can only be called with nonlinear constraints."; +static const char __pyx_k_addExprNonlinear_cannot_be_calle[] = "addExprNonlinear cannot be called in stage %i."; +static const char __pyx_k_branchexecext_is_a_fundamental_c[] = "branchexecext() is a fundamental callback and should be implemented in the derived class"; +static const char __pyx_k_branchexeclp_is_a_fundamental_ca[] = "branchexeclp() is a fundamental callback and should be implemented in the derived class"; +static const char __pyx_k_branchexecps_is_a_fundamental_ca[] = "branchexecps() is a fundamental callback and should be implemented in the derived class"; +static const char __pyx_k_cannot_create_BoundChange_with_S[] = "cannot create BoundChange with SCIP_BOUNDCHG* == NULL"; +static const char __pyx_k_cannot_create_Column_with_SCIP_C[] = "cannot create Column with SCIP_COL* == NULL"; +static const char __pyx_k_cannot_create_Constraint_with_SC[] = "cannot create Constraint with SCIP_CONS* == NULL"; +static const char __pyx_k_cannot_create_DomainChanges_with[] = "cannot create DomainChanges with SCIP_DOMCHG* == NULL"; +static const char __pyx_k_cannot_create_Event_with_SCIP_EV[] = "cannot create Event with SCIP_EVENT* == NULL"; +static const char __pyx_k_cannot_create_Model_with_SCIP_NU[] = "cannot create Model with SCIP* == NULL"; +static const char __pyx_k_cannot_create_NLRow_with_SCIP_NL[] = "cannot create NLRow with SCIP_NLROW* == NULL"; +static const char __pyx_k_cannot_create_Solution_with_SCIP[] = "cannot create Solution with SCIP* == NULL"; +static const char __pyx_k_cannot_create_Variable_with_SCIP[] = "cannot create Variable with SCIP_VAR* == NULL"; +static const char __pyx_k_checkBendersSubproblemOptimality[] = "checkBendersSubproblemOptimality"; +static const char __pyx_k_coefficients_not_available_for_c[] = "coefficients not available for constraints of type "; +static const char __pyx_k_could_not_change_variable_type_o[] = "could not change variable type of variable %s"; +static const char __pyx_k_dual_solution_values_not_availab[] = "dual solution values not available for constraints of type "; +static const char __pyx_k_expected_inequality_that_has_eit[] = "expected inequality that has either only a left or right hand side"; +static const char __pyx_k_expected_linear_inequality_expre[] = "expected linear inequality, expression has degree %d"; +static const char __pyx_k_given_coefficients_are_neither_E[] = "given coefficients are neither Expr or number but %s"; +static const char __pyx_k_given_constraint_is_not_ExprCons[] = "given constraint is not ExprCons but %s"; +static const char __pyx_k_given_constraint_is_not_linear_d[] = "given constraint is not linear, degree == %d"; +static const char __pyx_k_given_constraint_is_not_quadrati[] = "given constraint is not quadratic, degree == %d"; +static const char __pyx_k_linked_SCIP_is_not_compatible_to[] = "linked SCIP is not compatible to this version of PySCIPOpt - use at least version"; +static const char __pyx_k_linked_SCIP_is_not_recommended_f[] = "linked SCIP {} is not recommended for this version of PySCIPOpt - use version {}.{}.{}"; +static const char __pyx_k_method_can_only_be_called_in_sta[] = "method can only be called in stage PROBLEM"; +static const char __pyx_k_method_cannot_be_called_before_p[] = "method cannot be called before problem is solved"; +static const char __pyx_k_method_cannot_be_called_for_cons[] = "method cannot be called for constraints of type "; +static const char __pyx_k_no_reduced_cost_available_for_va[] = "no reduced cost available for variable "; +static const char __pyx_k_pricerfarkas_is_a_fundamental_ca[] = "pricerfarkas() is a fundamental callback and should be implemented in the derived class"; +static const char __pyx_k_pricerredcost_is_a_fundamental_c[] = "pricerredcost() is a fundamental callback and should be implemented in the derived class"; +static const char __pyx_k_python_error_in_benderscreatesub[] = "python error in benderscreatesub: this method needs to be implemented"; +static const char __pyx_k_python_error_in_benderscutexec_t[] = "python error in benderscutexec: this method needs to be implemented"; +static const char __pyx_k_python_error_in_bendersgetvar_th[] = "python error in bendersgetvar: this method needs to be implemented"; +static const char __pyx_k_python_error_in_conscheck_this_m[] = "python error in conscheck: this method needs to be implemented"; +static const char __pyx_k_python_error_in_consenforelax_th[] = "python error in consenforelax: this method needs to be implemented"; +static const char __pyx_k_python_error_in_conslock_this_me[] = "python error in conslock: this method needs to be implemented"; +static const char __pyx_k_python_error_in_eventexec_this_m[] = "python error in eventexec: this method needs to be implemented"; +static const char __pyx_k_python_error_in_heurexec_this_me[] = "python error in heurexec: this method needs to be implemented"; +static const char __pyx_k_python_error_in_propexec_this_me[] = "python error in propexec: this method needs to be implemented"; +static const char __pyx_k_python_error_in_propresprop_this[] = "python error in propresprop: this method needs to be implemented"; +static const char __pyx_k_python_error_in_relaxexec_this_m[] = "python error in relaxexec: this method needs to be implemented"; +static const char __pyx_k_relaxexec_must_return_a_dictiona[] = "relaxexec() must return a dictionary."; +static const char __pyx_k_self__benders_cannot_be_converte[] = "self._benders cannot be converted to a Python object for pickling"; +static const char __pyx_k_self__scip_self__valid_cannot_be[] = "self._scip,self._valid cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_event_cannot_be_converted_t[] = "self.event cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_boundchg_cannot_be_con[] = "self.scip_boundchg cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_col_cannot_be_converte[] = "self.scip_col cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_cons_cannot_be_convert[] = "self.scip_cons cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_domchg_cannot_be_conve[] = "self.scip_domchg cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_nlrow_cannot_be_conver[] = "self.scip_nlrow cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_node_cannot_be_convert[] = "self.scip_node cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_row_cannot_be_converte[] = "self.scip_row cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_self_sol_cannot_be_con[] = "self.scip,self.sol cannot be converted to a Python object for pickling"; +static const char __pyx_k_self_scip_var_cannot_be_converte[] = "self.scip_var cannot be converted to a Python object for pickling"; +static const char __pyx_k_term_length_must_be_1_or_2_but_i[] = "term length must be 1 or 2 but it is %s"; +static const char __pyx_k_wrote_parameter_settings_to_file[] = "wrote parameter settings to file "; +static const char __pyx_k_Given_constraint_list_is_not_ite_2[] = "Given constraint list is not iterable"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_2[] = "Incompatible checksums (0x%x vs (0x8863d2c, 0x181c0f9, 0x8f4795b) = (_lhs, _rhs, expr))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_3[] = "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_4[] = "Incompatible checksums (0x%x vs (0x3c52fb7, 0x911913a, 0x6d57035) = (_op, children, coefs, constant))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_5[] = "Incompatible checksums (0x%x vs (0xe54af0a, 0xbfe881d, 0x0d1f1a0) = (_op, children, constant))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_6[] = "Incompatible checksums (0x%x vs (0x496e932, 0x80e5b0b, 0xf1ef42d) = (_op, children, var))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_7[] = "Incompatible checksums (0x%x vs (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8) = (_op, children, expo))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_8[] = "Incompatible checksums (0x%x vs (0x7e75df4, 0xc30431f, 0x8ccbbec) = (_op, children, number))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_9[] = "Incompatible checksums (0x%x vs (0x5af043b, 0xc68d043, 0xfef88e0) = (benders, model, name))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_10[] = "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_11[] = "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0_12[] = "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())"; +/* #### Code section: decls ### */ +static PyObject *__pyx_lambda_funcdef_9pyscipopt_4scip_lambda7(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_lambda_funcdef_9pyscipopt_4scip_lambda8(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip__is_number(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_e); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2_expr_richcmp(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op); /* proto */ +static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_v); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_8__init___1genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_vartuple); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_2__getitem__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_idx); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_4__hash__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_6__eq__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_8__len__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_10__add__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_12__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4buildGenExprObj(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Expr___init__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_terms); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_2__getitem__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_4__iter__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_6__next__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_8__abs__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_10__add__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_12__iadd__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_14__mul__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_16__truediv__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_18__rtruediv__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_20__pow__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other, CYTHON_UNUSED PyObject *__pyx_v_modulo); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_22__neg__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_24__sub__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_26__radd__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_28__rmul__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_30__rsub__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_32__richcmp__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_34normalize(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_36__repr__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_6degree_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_38degree(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_5terms___get__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Expr_5terms_2__set__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Expr_5terms_4__del__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_40__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_42__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ExprCons___init__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_expr, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_2normalize(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_4__richcmp__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_6__repr__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_8__nonzero__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_4expr___get__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4expr_2__set__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4expr_4__del__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs___get__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs_2__set__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs_4__del__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs___get__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs_2__set__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs_4__del__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_10__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_12__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6quicksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_termlist); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8quickprod(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_termlist); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7GenExpr___init__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_2__abs__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_4__add__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_6__mul__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_8__pow__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other, CYTHON_UNUSED PyObject *__pyx_v_modulo); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_10__truediv__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_12__rtruediv__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_14__neg__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_16__sub__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_18__radd__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_20__rmul__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_22__rsub__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_24__richcmp__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_26degree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_28getOp(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_3_op___get__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7GenExpr_3_op_2__set__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7GenExpr_3_op_4__del__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_8children___get__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7GenExpr_8children_2__set__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7GenExpr_8children_4__del__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_30__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_32__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7SumExpr___init__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_lambda_funcdef_lambda3(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_child); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_8constant___get__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7SumExpr_8constant_2__set__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7SumExpr_8constant_4__del__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs___get__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs_2__set__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs_4__del__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ProdExpr___init__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_lambda_funcdef_lambda4(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_child); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ProdExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant___get__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant_2__set__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant_4__del__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ProdExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8ProdExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7VarExpr___init__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self, PyObject *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7VarExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7VarExpr_3var___get__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7VarExpr_3var_2__set__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7VarExpr_3var_4__del__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7VarExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7VarExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7PowExpr___init__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7PowExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7PowExpr_4expo___get__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7PowExpr_4expo_2__set__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7PowExpr_4expo_4__del__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7PowExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7PowExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_9UnaryExpr___init__(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v_self, PyObject *__pyx_v_op, PyObject *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9UnaryExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9UnaryExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9UnaryExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Constant___init__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self, PyObject *__pyx_v_number); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Constant_2__repr__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Constant_6number___get__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Constant_6number_2__set__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Constant_6number_4__del__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Constant_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Constant_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10exp(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_12log(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_14sqrt(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_16sin(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_18cos(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_20expr_to_nodes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_22value_to_array(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_val, PyObject *__pyx_v_nodes); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_24expr_to_array(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr, PyObject *__pyx_v_nodes); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_2LP___init__(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_sense); /* proto */ +static void __pyx_pf_9pyscipopt_4scip_2LP_2__dealloc__(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_4__repr__(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_6writeLP(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_8readLP(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_10infinity(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_12isInfinity(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_14addCol(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_entries, PyObject *__pyx_v_obj, PyObject *__pyx_v_lb, PyObject *__pyx_v_ub); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_7addCols_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_16addCols(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_entrieslist, PyObject *__pyx_v_objs, PyObject *__pyx_v_lbs, PyObject *__pyx_v_ubs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_18delCols(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_firstcol, PyObject *__pyx_v_lastcol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_20addRow(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_entries, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_7addRows_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_22addRows(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_entrieslist, PyObject *__pyx_v_lhss, PyObject *__pyx_v_rhss); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_24delRows(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_firstrow, PyObject *__pyx_v_lastrow); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_26getBounds(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_firstcol, PyObject *__pyx_v_lastcol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_28getSides(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_firstrow, PyObject *__pyx_v_lastrow); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_30chgObj(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_col, PyObject *__pyx_v_obj); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_32chgCoef(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_row, PyObject *__pyx_v_col, PyObject *__pyx_v_newval); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_34chgBound(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_col, PyObject *__pyx_v_lb, PyObject *__pyx_v_ub); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_36chgSide(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_row, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_38clear(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_40nrows(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_42ncols(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_44solve(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_dual); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_46getPrimal(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_48isPrimalFeasible(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_50getDual(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_52isDualFeasible(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_54getPrimalRay(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_56getDualRay(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_58getNIterations(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_60getRedcost(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_62getBasisInds(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_4name___get__(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_64__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_66__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_bendersfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_2bendersinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_4bendersexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_6bendersinitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_8bendersexitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_10bendersinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_12bendersexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_14benderscreatesub(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_probnumber); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_16benderspresubsolve(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_enfotype, CYTHON_UNUSED PyObject *__pyx_v_checkint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_18benderssolvesubconvex(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_probnumber, CYTHON_UNUSED PyObject *__pyx_v_onlyconvex); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_20benderssolvesub(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_probnumber); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_22benderspostsolve(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_enfotype, CYTHON_UNUSED PyObject *__pyx_v_mergecandidates, CYTHON_UNUSED PyObject *__pyx_v_npriomergecands, CYTHON_UNUSED PyObject *__pyx_v_checkint, CYTHON_UNUSED PyObject *__pyx_v_infeasible); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_24bendersfreesub(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_probnumber); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_26bendersgetvar(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_variable, CYTHON_UNUSED PyObject *__pyx_v_probnumber); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7Benders_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7Benders_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7Benders_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7Benders_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_benderscutfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_2benderscutinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_4benderscutexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_6benderscutinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_8benderscutexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_10benderscutexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_probnumber, CYTHON_UNUSED PyObject *__pyx_v_enfotype); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_7benders___get__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_7benders_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_7benders_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_branchfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_2branchinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_4branchexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_6branchinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_8branchexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_10branchexeclp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_allowaddcons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_12branchexecext(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_allowaddcons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_14branchexecps(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_allowaddcons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Branchrule_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Branchrule_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_16__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_18__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_consfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_2consinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_4consexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_6consinitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_8consexitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_10consinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_12consexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_restart); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_14consdelete(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_16constrans(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_sourceconstraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_18consinitlp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_20conssepalp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_22conssepasol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_solution); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_24consenfolp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_solinfeasible); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_26consenforelax(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_solinfeasible); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_28consenfops(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_solinfeasible, CYTHON_UNUSED PyObject *__pyx_v_objinfeasible); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_30conscheck(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_checkintegrality, CYTHON_UNUSED PyObject *__pyx_v_checklprows, CYTHON_UNUSED PyObject *__pyx_v_printreason, CYTHON_UNUSED PyObject *__pyx_v_completely); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_32consprop(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_nmarkedconss, CYTHON_UNUSED PyObject *__pyx_v_proptiming); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_34conspresol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nrounds, CYTHON_UNUSED PyObject *__pyx_v_presoltiming, CYTHON_UNUSED PyObject *__pyx_v_nnewfixedvars, CYTHON_UNUSED PyObject *__pyx_v_nnewaggrvars, CYTHON_UNUSED PyObject *__pyx_v_nnewchgvartypes, CYTHON_UNUSED PyObject *__pyx_v_nnewchgbds, CYTHON_UNUSED PyObject *__pyx_v_nnewholes, CYTHON_UNUSED PyObject *__pyx_v_nnewdelconss, CYTHON_UNUSED PyObject *__pyx_v_nnewaddconss, CYTHON_UNUSED PyObject *__pyx_v_nnewupgdconss, CYTHON_UNUSED PyObject *__pyx_v_nnewchgcoefs, CYTHON_UNUSED PyObject *__pyx_v_nnewchgsides, PyObject *__pyx_v_result_dict); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_36consresprop(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_38conslock(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint, CYTHON_UNUSED PyObject *__pyx_v_locktype, CYTHON_UNUSED PyObject *__pyx_v_nlockspos, CYTHON_UNUSED PyObject *__pyx_v_nlocksneg); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_40consactive(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_42consdeactive(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_44consenable(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_46consdisable(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_48consdelvars(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_50consprint(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_52conscopy(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_54consparse(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_56consgetvars(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_58consgetnvars(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_60consgetdivebdchgs(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_62consgetpermsymgraph(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_64consgetsignedpermsymgraph(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Conshdlr_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Conshdlr_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Conshdlr_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Conshdlr_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_66__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_68__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_cutselfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_2cutselinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_4cutselexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_6cutselinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_8cutselexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_10cutselselect(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_cuts, CYTHON_UNUSED PyObject *__pyx_v_forcedcuts, CYTHON_UNUSED PyObject *__pyx_v_root, CYTHON_UNUSED PyObject *__pyx_v_maxnselectedcuts); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Cutsel_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Cutsel_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_eventcopy(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_2eventfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_4eventinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_6eventexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_8eventinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_10eventexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_12eventdelete(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_14eventexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_event); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_16__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_18__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_heurfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_2heurinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_4heurexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_6heurinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_8heurexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_10heurexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_heurtiming, CYTHON_UNUSED PyObject *__pyx_v_nodeinfeasible); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Heur_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Heur_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Heur_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Heur_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_presolfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_2presolinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_4presolexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_6presolinitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_8presolexitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_10presolexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_nrounds, CYTHON_UNUSED PyObject *__pyx_v_presoltiming); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Presol_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Presol_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_pricerfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_2pricerinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_4pricerexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_6pricerinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_8pricerexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_10pricerredcost(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_12pricerfarkas(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Pricer_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Pricer_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_14__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_16__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_propfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_2propinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_4propexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_6propinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_8propexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_restart); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_10propinitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_12propexitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_14proppresol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_nrounds, CYTHON_UNUSED PyObject *__pyx_v_presoltiming, CYTHON_UNUSED PyObject *__pyx_v_result_dict); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_16propexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_proptiming); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_18propresprop(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_confvar, CYTHON_UNUSED PyObject *__pyx_v_inferinfo, CYTHON_UNUSED PyObject *__pyx_v_bdtype, CYTHON_UNUSED PyObject *__pyx_v_relaxedbd); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Prop_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Prop_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_20__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_22__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_sepafree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_2sepainit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_4sepaexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_6sepainitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_8sepaexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_10sepaexeclp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_12sepaexecsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Sepa_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Sepa_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Sepa_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Sepa_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_14__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_16__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_readerfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_2readerread(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_4readerwrite(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_file, CYTHON_UNUSED PyObject *__pyx_v_name, CYTHON_UNUSED PyObject *__pyx_v_transformed, CYTHON_UNUSED PyObject *__pyx_v_objsense, CYTHON_UNUSED PyObject *__pyx_v_objscale, CYTHON_UNUSED PyObject *__pyx_v_objoffset, CYTHON_UNUSED PyObject *__pyx_v_binvars, CYTHON_UNUSED PyObject *__pyx_v_intvars, CYTHON_UNUSED PyObject *__pyx_v_implvars, CYTHON_UNUSED PyObject *__pyx_v_contvars, CYTHON_UNUSED PyObject *__pyx_v_fixedvars, CYTHON_UNUSED PyObject *__pyx_v_startnvars, CYTHON_UNUSED PyObject *__pyx_v_conss, CYTHON_UNUSED PyObject *__pyx_v_maxnconss, CYTHON_UNUSED PyObject *__pyx_v_startnconss, CYTHON_UNUSED PyObject *__pyx_v_genericnames); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Reader_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Reader_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Reader_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Reader_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_6__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_8__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_relaxfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_2relaxinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_4relaxexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_6relaxinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_8relaxexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_10relaxexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Relax_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Relax_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Relax_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Relax_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_nodefree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_2nodeinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_4nodeexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_6nodeinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_8nodeexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_10nodeselect(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_12nodecomp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_node1, CYTHON_UNUSED PyObject *__pyx_v_node2); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7Nodesel_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_7Nodesel_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_14__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_16__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_14PY_SCIP_RESULT___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_14PY_SCIP_RESULT_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_14PY_SCIP_STATUS___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_14PY_SCIP_STATUS_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_13PY_SCIP_STAGE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_13PY_SCIP_STAGE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_16PY_SCIP_NODETYPE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_16PY_SCIP_NODETYPE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_18PY_SCIP_PROPTIMING___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_18PY_SCIP_HEURTIMING___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_26PY_SCIP_CALL(CYTHON_UNUSED PyObject *__pyx_self, SCIP_RETCODE __pyx_v_rc); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_getType(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_2getName(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_4_getEventNames(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_6__repr__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_8__str__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_10getNewBound(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_12getOldBound(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_14getVar(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_16getNode(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_18getRow(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static Py_hash_t __pyx_pf_9pyscipopt_4scip_5Event_20__hash__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_22__eq__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Event_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Event_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_getLPPos(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_2getBasisStatus(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_4isIntegral(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_6getVar(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_8getPrimsol(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_10getLb(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_12getUb(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_14getObjCoeff(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static Py_hash_t __pyx_pf_9pyscipopt_4scip_6Column_16__hash__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_18__eq__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Column_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_6Column_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_20__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_22__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_getLhs(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_2getRhs(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_4getConstant(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_6getLPPos(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_8getBasisStatus(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_10isIntegral(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_12isLocal(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_14isModifiable(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_16isRemovable(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_18isInGlobalCutpool(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_20getOrigintype(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_22getConsOriginConshdlrtype(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_24getNNonz(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_26getNLPNonz(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_28getCols(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_30getVals(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_32getNorm(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static Py_hash_t __pyx_pf_9pyscipopt_4scip_3Row_34__hash__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_36__eq__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_3Row_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_3Row_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_38__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_40__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_4name___get__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_getConstant(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_2getLinearTerms(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_4getLhs(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_6getRhs(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_8getDualsol(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static Py_hash_t __pyx_pf_9pyscipopt_4scip_5NLRow_10__hash__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_12__eq__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_4data___get__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5NLRow_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5NLRow_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Solution___init__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, PyObject *__pyx_v_raise_error); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_11__getitem___genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_2__getitem__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_4_evaluate(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, PyObject *__pyx_v_term); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Solution_6__setitem__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_8__repr__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_10_checkStage(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, PyObject *__pyx_v_method); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Solution_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Solution_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_getNewBound(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_2getVar(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_4getBoundchgtype(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_6getBoundtype(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_8isRedundant(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_10__repr__(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_13DomainChanges_getBoundchgs(struct __pyx_obj_9pyscipopt_4scip_DomainChanges *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_13DomainChanges_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_DomainChanges *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_13DomainChanges_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_DomainChanges *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_getParent(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_2getNumber(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_4getDepth(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_6getType(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_8getLowerbound(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_10getEstimate(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_12getAddedConss(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_14getNAddedConss(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_16isActive(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_18isPropagatedAgain(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_20getNParentBranchings(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_22getParentBranchings(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_24getNDomchg(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_26getDomchg(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static Py_hash_t __pyx_pf_9pyscipopt_4scip_4Node_28__hash__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_30__eq__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Node_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_4Node_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_32__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_34__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_ptr(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_2__repr__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_4vtype(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_6isOriginal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_8isInLP(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_10getIndex(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_12getCol(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_14getLbOriginal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_16getUbOriginal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_18getLbGlobal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_20getUbGlobal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_22getLbLocal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_24getUbLocal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_26getObj(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_28getLPSol(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Variable_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_8Variable_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_30__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_32__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint___repr__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_2isOriginal(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_4isInitial(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_6isSeparated(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_8isEnforced(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_10isChecked(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_12isPropagated(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_14isLocal(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_16isModifiable(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_18isDynamic(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_20isRemovable(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_22isStickingAtNode(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_24isActive(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_26isLinear(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_28isNonlinear(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_30getConshdlrName(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static Py_hash_t __pyx_pf_9pyscipopt_4scip_10Constraint_32__hash__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_34__eq__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Constraint_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_10Constraint_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_36__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_38__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Model___init__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_problemName, PyObject *__pyx_v_defaultPlugins, struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_sourceModel, PyObject *__pyx_v_origcopy, PyObject *__pyx_v_globalcopy, PyObject *__pyx_v_enablepricing, PyObject *__pyx_v_createscip, PyObject *__pyx_v_threadsafe); /* proto */ +static void __pyx_pf_9pyscipopt_4scip_5Model_2__dealloc__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static Py_hash_t __pyx_pf_9pyscipopt_4scip_5Model_4__hash__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_6__eq__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_9_freescip___get__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Model_9_freescip_2__set__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_8from_ptr(PyObject *__pyx_v_capsule, PyObject *__pyx_v_take_ownership); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_10to_ptr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_give_ownership); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_12includeDefaultPlugins(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_14createProbBasic(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_problemName); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_16freeProb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_18freeTransform(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_20version(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_22printVersion(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_24printExternalCodeVersions(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_26getProbName(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_28getTotalTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_30getSolvingTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_32getReadingTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_34getPresolvingTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_36getNLPIterations(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_38getNNodes(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_40getNTotalNodes(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_42getNFeasibleLeaves(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_44getNInfeasibleLeaves(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_46getNLeaves(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_48getNChildren(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_50getNSiblings(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_52getCurrentNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_54getGap(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_56getDepth(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_58infinity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_60epsilon(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_62feastol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_64feasFrac(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_66frac(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_68isZero(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_70isFeasZero(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_72isInfinity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_74isFeasNegative(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_76isFeasIntegral(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_78isEQ(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_80isFeasEQ(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_82isLE(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_84isLT(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_86isGE(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_88isGT(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_90getCondition(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_exact); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_92enableReoptimization(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_enable); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_94lpiGetIterations(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_96setMinimize(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_98setMaximize(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_100setObjlimit(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_objlimit); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_102getObjlimit(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_104setObjective(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_expr, PyObject *__pyx_v_sense, PyObject *__pyx_v_clear); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_106getObjective(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_108addObjoffset(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_offset, PyObject *__pyx_v_solutions); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_110getObjoffset(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_original); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_112setObjIntegral(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_114getLocalEstimate(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_original); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_116setPresolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_setting); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_118setProbName(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_120setSeparating(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_setting); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_122setHeuristics(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_setting); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_124disablePropagation(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_onlyroot); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_126writeProblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_trans, PyObject *__pyx_v_genericnames, PyObject *__pyx_v_verbose); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_128addVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_vtype, PyObject *__pyx_v_lb, PyObject *__pyx_v_ub, PyObject *__pyx_v_obj, PyObject *__pyx_v_pricedVar, PyObject *__pyx_v_pricedVarScore); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_130getTransformedVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_132addVarLocks(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_nlocksdown, PyObject *__pyx_v_nlocksup); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_134fixVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_val); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_136delVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_138tightenVarLb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb, PyObject *__pyx_v_force); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_140tightenVarUb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub, PyObject *__pyx_v_force); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_142tightenVarUbGlobal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub, PyObject *__pyx_v_force); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_144tightenVarLbGlobal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb, PyObject *__pyx_v_force); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_146chgVarLb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_148chgVarUb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_150chgVarLbGlobal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_152chgVarUbGlobal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_154chgVarLbNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_156chgVarUbNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_158chgVarType(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_vtype); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_160getVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_transformed); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_162getNVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_transformed); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_164getNIntVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_166getNBinVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_168getVarDict(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_170updateNodeLowerbound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node, PyObject *__pyx_v_lb); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_172relax(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_174getBestChild(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_176getBestSibling(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_178getBestLeaf(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_180getBestNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_182getBestboundNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_184getOpenNodes(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_186repropagateNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_188getLPSolstat(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_190constructLP(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_192getLPObjVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_194getLPColsData(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_196getLPRowsData(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_198getNLPRows(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_200getNLPCols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_202getLPBasisInd(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_204getLPBInvRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_206getLPBInvARow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_208isLPSolBasic(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_210createEmptyRowSepa(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_sepa, PyObject *__pyx_v_name, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_removable); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_212createEmptyRowUnspec(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_removable); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_214getRowActivity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_216getRowLPActivity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_218releaseRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_220cacheRowExtensions(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_222flushRowExtensions(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_224addVarToRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_226printRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_228getRowNumIntCols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_230getRowObjParallelism(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_232getRowParallelism(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row1, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row2, PyObject *__pyx_v_orthofunc); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_234getRowDualSol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_236addPoolCut(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_238getCutEfficacy(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_240isCutEfficacious(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_242getCutLPSolCutoffDistance(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_244addCut(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut, PyObject *__pyx_v_forcecut); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_246getNCuts(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_248getNCutsApplied(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_250getNSepaRounds(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_252separateSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol, PyObject *__pyx_v_pretendroot, PyObject *__pyx_v_allowlocal, PyObject *__pyx_v_onlydelayed); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_254_createConsLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_lincons, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_256_createConsQuadratic(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_quadcons, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_258_createConsNonlinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_260_createConsGenNonlinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_262createConsFromExpr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_264addCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_elem, PyObject *__pyx_v_length); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_266addConss(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_conss, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_18addConsDisjunction_ensure_iterable(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_elem, PyObject *__pyx_v_length); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_268addConsDisjunction(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_conss, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, CYTHON_UNUSED PyObject *__pyx_v_relaxcons, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_270addConsElemDisjunction(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_disj_cons, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_272getConsNVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_274getConsVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_276printCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_278addExprNonlinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_expr, float __pyx_v_coef); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_280addConsCoeff(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_coeff); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_282addConsNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_validnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_284addConsLocal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_validnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_286addConsSOS1(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_weights, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_288addConsSOS2(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_weights, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_290addConsAnd(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_resvar, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_292addConsOr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_resvar, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_294addConsXor(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_rhsvar, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_296addConsCardinality(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_consvars, PyObject *__pyx_v_cardval, PyObject *__pyx_v_indvars, PyObject *__pyx_v_weights, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_298addConsIndicator(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_binvar, PyObject *__pyx_v_activeone, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_300getSlackVarIndicator(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_302addPyCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_304addVarSOS1(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_306appendVarSOS1(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_308addVarSOS2(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_weight); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_310appendVarSOS2(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_312setInitial(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_newInit); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_314setRemovable(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_newRem); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_316setEnforced(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_newEnf); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_318setCheck(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_newCheck); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_320chgRhs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_rhs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_322chgLhs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_lhs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_324getRhs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_326getLhs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_328chgCoefLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_330delCoefLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_332addCoefLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_334getActivity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_336getSlack(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol, PyObject *__pyx_v_side); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_338getTransformedCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_340isNLPConstructed(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_342getNNlRows(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_344getNlRows(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_346getNlRowSolActivity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_348getNlRowSolFeasibility(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_350getNlRowActivityBounds(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_352printNlRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_354checkQuadraticNonlinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_356getTermsQuadratic(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_358setRelaxSolVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_val); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_360getConss(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_transformed); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_362getNConss(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_transformed); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_364delCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_366delConsLocal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_368getValsLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_370getRowLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_372getDualsolLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_374getDualMultiplier(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_376getDualfarkasLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_378getVarRedcost(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_380getDualSolVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_boundconstraint); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_382optimize(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_384solveConcurrent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_386presolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_388initBendersDefault(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_subproblems); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_390computeBestSolSubproblems(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_392freeBendersSubproblems(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_394updateBendersLowerbounds(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_lowerbounds, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_396activateBenders(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, int __pyx_v_nsubproblems); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_398addBendersSubproblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, PyObject *__pyx_v_subproblem); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_400setBendersSubproblemIsConvex(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, PyObject *__pyx_v_probnumber, PyObject *__pyx_v_isconvex); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_402setupBendersSubproblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probnumber, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_checktype); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_404solveBendersSubproblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probnumber, PyObject *__pyx_v_solvecip, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_406getBendersSubproblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probnumber, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_408getBendersVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, PyObject *__pyx_v_probnumber); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_410getBendersAuxiliaryVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probnumber, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_412checkBendersSubproblemOptimality(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_probnumber, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_414includeBendersDefaultCuts(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_416includeEventhdlr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr, PyObject *__pyx_v_name, PyObject *__pyx_v_desc); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_418includePricer(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_pricer, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_delay); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_420includeConshdlr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_conshdlr, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_sepapriority, PyObject *__pyx_v_enfopriority, PyObject *__pyx_v_chckpriority, PyObject *__pyx_v_sepafreq, PyObject *__pyx_v_propfreq, PyObject *__pyx_v_eagerfreq, PyObject *__pyx_v_maxprerounds, PyObject *__pyx_v_delaysepa, PyObject *__pyx_v_delayprop, PyObject *__pyx_v_needscons, PyObject *__pyx_v_proptiming, PyObject *__pyx_v_presoltiming); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_422createCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_conshdlr, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_424includePresol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_presol, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_maxrounds, PyObject *__pyx_v_timing); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_426includeSepa(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_sepa, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_freq, PyObject *__pyx_v_maxbounddist, PyObject *__pyx_v_usessubscip, PyObject *__pyx_v_delay); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_428includeReader(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_reader, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_ext); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_430includeProp(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_prop, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_presolpriority, PyObject *__pyx_v_presolmaxrounds, PyObject *__pyx_v_proptiming, PyObject *__pyx_v_presoltiming, PyObject *__pyx_v_priority, PyObject *__pyx_v_freq, PyObject *__pyx_v_delay); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_432includeHeur(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_dispchar, PyObject *__pyx_v_priority, PyObject *__pyx_v_freq, PyObject *__pyx_v_freqofs, PyObject *__pyx_v_maxdepth, PyObject *__pyx_v_timingmask, PyObject *__pyx_v_usessubscip); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_434includeRelax(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_relax, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_freq); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_436includeCutsel(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_cutsel, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_438includeBranchrule(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_branchrule, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_maxdepth, PyObject *__pyx_v_maxbounddist); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_440includeNodesel(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_nodesel, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_stdpriority, PyObject *__pyx_v_memsavepriority); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_442includeBenders(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_cutlp, PyObject *__pyx_v_cutpseudo, PyObject *__pyx_v_cutrelax, PyObject *__pyx_v_shareaux); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_444includeBenderscut(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_benderscut, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_islpcut); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_446getLPBranchCands(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_448getPseudoBranchCands(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_450branchVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_452branchVarVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_variable, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_454calcNodeselPriority(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable, PyObject *__pyx_v_branchdir, PyObject *__pyx_v_targetvalue); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_456calcChildEstimate(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable, PyObject *__pyx_v_targetvalue); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_458createChild(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_nodeselprio, PyObject *__pyx_v_estimate); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_460startDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_462endDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_464chgVarObjDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_newobj); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_466chgVarLbDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_newbound); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_468chgVarUbDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_newbound); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_470getVarLbDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_472getVarUbDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_474chgRowLhsDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, PyObject *__pyx_v_newlhs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_476chgRowRhsDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, PyObject *__pyx_v_newrhs); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_478addRowDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_480solveDiveLP(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_itlim); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_482inRepropagation(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_484startProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_486endProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_488newProbingNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_490backtrackProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probingdepth); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_492getProbingDepth(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_494chgVarObjProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_newobj); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_496chgVarLbProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_498chgVarUbProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_500fixVarProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_fixedval); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_502isObjChangedProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_504inProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_506solveProbingLP(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_itlim); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_508applyCutsProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_510propagateProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_maxproprounds); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_512interruptSolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_514restartSolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_516writeLP(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_518createSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_520createPartialSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_522createOrigSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_524printBestSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_write_zeros); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_526printSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_write_zeros); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_528writeBestSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_write_zeros); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_530writeBestTransSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_write_zeros); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_532writeSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_filename, PyObject *__pyx_v_write_zeros); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_534writeTransSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_filename, PyObject *__pyx_v_write_zeros); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_536readSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_538readSolFile(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_540setSolVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_val); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_542trySol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_printreason, PyObject *__pyx_v_completely, PyObject *__pyx_v_checkbounds, PyObject *__pyx_v_checkintegrality, PyObject *__pyx_v_checklprows, PyObject *__pyx_v_free); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_544checkSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_printreason, PyObject *__pyx_v_completely, PyObject *__pyx_v_checkbounds, PyObject *__pyx_v_checkintegrality, PyObject *__pyx_v_checklprows, PyObject *__pyx_v_original); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_546addSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_free); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_548freeSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_550getNSols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_552getNSolsFound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_554getNLimSolsFound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_556getNBestSolsFound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_558getSols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_560getBestSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_562getSolObjVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol, PyObject *__pyx_v_original); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_564getSolTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_566getObjVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_original); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_568getSolVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol, struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_570getVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_expr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_572hasPrimalRay(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_574getPrimalRayVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_576getPrimalRay(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_578getPrimalbound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_580getDualbound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_582getDualboundRoot(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_584writeName(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_586getStage(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_588getStageName(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_590_getStageNames(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_592getStatus(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_594getObjectiveSense(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_596catchEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_598dropEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_600catchVarEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_602dropVarEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_604catchRowEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_606dropRowEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_608printStatistics(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_610writeStatistics(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_612getNLPs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_614hideOutput(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_quiet); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_616redirectOutput(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_618setLogfile(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_path); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_620setBoolParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_622setIntParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_624setLongintParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_626setRealParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_628setCharParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_630setStringParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_632setParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_634getParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_636getParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_638setParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_params); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_640readParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_file); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_642writeParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_comments, PyObject *__pyx_v_onlychanged, PyObject *__pyx_v_verbose); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_644resetParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_646resetParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_648setEmphasis(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_paraemphasis, PyObject *__pyx_v_quiet); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_650readProblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_extension); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_652count(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_654getNReaders(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_656getNCountedSols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_658setParamsCountsols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_660freeReoptSolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_662chgReoptObjective(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_coeffs, PyObject *__pyx_v_sense); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_664chgVarBranchPriority(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_priority); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_666getTreesizeEstimation(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Model_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_9pyscipopt_4scip_5Model_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_668__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_670__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_28is_memory_freed(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_30print_memory_in_use(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_32__pyx_unpickle_Expr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_34__pyx_unpickle_ExprCons(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_36__pyx_unpickle_GenExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_38__pyx_unpickle_SumExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_40__pyx_unpickle_ProdExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_42__pyx_unpickle_VarExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_44__pyx_unpickle_PowExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_46__pyx_unpickle_UnaryExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_48__pyx_unpickle_Constant(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_50__pyx_unpickle_Benderscut(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_52__pyx_unpickle_Branchrule(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_54__pyx_unpickle_Conshdlr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_56__pyx_unpickle_Cutsel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_58__pyx_unpickle_Eventhdlr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_60__pyx_unpickle_Heur(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_62__pyx_unpickle_Presol(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_64__pyx_unpickle_Pricer(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_66__pyx_unpickle_Prop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_68__pyx_unpickle_Sepa(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_70__pyx_unpickle_Reader(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_72__pyx_unpickle_Relax(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_74__pyx_unpickle_Nodesel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_78__pyx_unpickle_PY_SCIP_RESULT(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_80__pyx_unpickle_PY_SCIP_PARAMSETTING(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_82__pyx_unpickle_PY_SCIP_PARAMEMPHASIS(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_84__pyx_unpickle_PY_SCIP_STATUS(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_86__pyx_unpickle_PY_SCIP_STAGE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_88__pyx_unpickle_PY_SCIP_NODETYPE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_90__pyx_unpickle_PY_SCIP_PROPTIMING(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_92__pyx_unpickle_PY_SCIP_PRESOLTIMING(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_94__pyx_unpickle_PY_SCIP_HEURTIMING(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_96__pyx_unpickle_PY_SCIP_EVENTTYPE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_98__pyx_unpickle_PY_SCIP_LPSOLSTAT(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_100__pyx_unpickle_PY_SCIP_BRANCHDIR(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_102__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_9pyscipopt_4scip_104__pyx_unpickle_PY_SCIP_ROWORIGINTYPE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Expr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Event(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Column(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Row(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_NLRow(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Solution(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_DomainChanges(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_BoundChange(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Node(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Variable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Constraint(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Model(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_ExprCons(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_GenExpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_SumExpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_ProdExpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_VarExpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PowExpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Constant(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_LP(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Benders(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Benderscut(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Branchrule(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Conshdlr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Cutsel(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Eventhdlr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Heur(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Presol(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Pricer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Prop(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Sepa(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Reader(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Relax(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Nodesel(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_RESULT(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PARAMSETTING(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_STATUS(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_STAGE(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_NODETYPE(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PROPTIMING(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_HEURTIMING(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_EVENTTYPE(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_BRANCHDIR(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct__genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_2_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_3_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_4___getitem__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_5_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_get = {0, 0, 0, 0, 0}; +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4type_type; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_4bool_bool; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + PyTypeObject *__pyx_ptype_7cpython_7complex_complex; + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_9pyscipopt_4scip_Expr; + PyObject *__pyx_type_9pyscipopt_4scip_Event; + PyObject *__pyx_type_9pyscipopt_4scip_Column; + PyObject *__pyx_type_9pyscipopt_4scip_Row; + PyObject *__pyx_type_9pyscipopt_4scip_NLRow; + PyObject *__pyx_type_9pyscipopt_4scip_Solution; + PyObject *__pyx_type_9pyscipopt_4scip_DomainChanges; + PyObject *__pyx_type_9pyscipopt_4scip_BoundChange; + PyObject *__pyx_type_9pyscipopt_4scip_Node; + PyObject *__pyx_type_9pyscipopt_4scip_Variable; + PyObject *__pyx_type_9pyscipopt_4scip_Constraint; + PyObject *__pyx_type_9pyscipopt_4scip_Model; + PyObject *__pyx_type_9pyscipopt_4scip_ExprCons; + PyObject *__pyx_type_9pyscipopt_4scip_GenExpr; + PyObject *__pyx_type_9pyscipopt_4scip_SumExpr; + PyObject *__pyx_type_9pyscipopt_4scip_ProdExpr; + PyObject *__pyx_type_9pyscipopt_4scip_VarExpr; + PyObject *__pyx_type_9pyscipopt_4scip_PowExpr; + PyObject *__pyx_type_9pyscipopt_4scip_UnaryExpr; + PyObject *__pyx_type_9pyscipopt_4scip_Constant; + PyObject *__pyx_type_9pyscipopt_4scip_LP; + PyObject *__pyx_type_9pyscipopt_4scip_Benders; + PyObject *__pyx_type_9pyscipopt_4scip_Benderscut; + PyObject *__pyx_type_9pyscipopt_4scip_Branchrule; + PyObject *__pyx_type_9pyscipopt_4scip_Conshdlr; + PyObject *__pyx_type_9pyscipopt_4scip_Cutsel; + PyObject *__pyx_type_9pyscipopt_4scip_Eventhdlr; + PyObject *__pyx_type_9pyscipopt_4scip_Heur; + PyObject *__pyx_type_9pyscipopt_4scip_Presol; + PyObject *__pyx_type_9pyscipopt_4scip_Pricer; + PyObject *__pyx_type_9pyscipopt_4scip_Prop; + PyObject *__pyx_type_9pyscipopt_4scip_Sepa; + PyObject *__pyx_type_9pyscipopt_4scip_Reader; + PyObject *__pyx_type_9pyscipopt_4scip_Relax; + PyObject *__pyx_type_9pyscipopt_4scip_Nodesel; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE; + PyObject *__pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE; + PyObject *__pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr; + PyObject *__pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr; + PyObject *__pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr; + PyObject *__pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr; + PyObject *__pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem__; + PyObject *__pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr; + #endif + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Expr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Event; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Column; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Row; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_NLRow; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Solution; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_DomainChanges; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_BoundChange; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Node; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Variable; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Constraint; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Model; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_ExprCons; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_GenExpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_SumExpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_ProdExpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_VarExpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PowExpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_UnaryExpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Constant; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_LP; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Benders; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Benderscut; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Branchrule; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Conshdlr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Cutsel; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Eventhdlr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Heur; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Presol; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Pricer; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Prop; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Sepa; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Reader; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Relax; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_Nodesel; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__; + PyTypeObject *__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr; + PyObject *__pyx_n_s_AFTERLPLOOP; + PyObject *__pyx_n_s_AFTERLPNODE; + PyObject *__pyx_n_s_AFTERLPPLUNGE; + PyObject *__pyx_n_s_AFTERPROPLOOP; + PyObject *__pyx_n_s_AFTERPSEUDONODE; + PyObject *__pyx_n_s_AFTERPSEUDOPLUNGE; + PyObject *__pyx_n_s_AGGRESSIVE; + PyObject *__pyx_n_u_ANDcons; + PyObject *__pyx_n_s_AUTO; + PyObject *__pyx_n_s_AssertionError; + PyObject *__pyx_n_u_B; + PyObject *__pyx_n_s_BEFORELP; + PyObject *__pyx_n_s_BEFORENODE; + PyObject *__pyx_n_s_BEFOREPRESOL; + PyObject *__pyx_n_s_BENCHMARK; + PyObject *__pyx_n_s_BESTSOLFOUND; + PyObject *__pyx_n_s_BESTSOLLIMIT; + PyObject *__pyx_n_u_BINARY; + PyObject *__pyx_n_s_BOUNDCHANGED; + PyObject *__pyx_n_s_BOUNDRELAXED; + PyObject *__pyx_n_s_BOUNDTIGHTENED; + PyObject *__pyx_n_s_BRANCHED; + PyObject *__pyx_n_s_Benders; + PyObject *__pyx_n_s_Benders___reduce_cython; + PyObject *__pyx_n_s_Benders___setstate_cython; + PyObject *__pyx_n_s_Benders_benderscreatesub; + PyObject *__pyx_n_s_Benders_bendersexit; + PyObject *__pyx_n_s_Benders_bendersexitpre; + PyObject *__pyx_n_s_Benders_bendersexitsol; + PyObject *__pyx_n_s_Benders_bendersfree; + PyObject *__pyx_n_s_Benders_bendersfreesub; + PyObject *__pyx_n_s_Benders_bendersgetvar; + PyObject *__pyx_n_s_Benders_bendersinit; + PyObject *__pyx_n_s_Benders_bendersinitpre; + PyObject *__pyx_n_s_Benders_bendersinitsol; + PyObject *__pyx_n_s_Benders_benderspostsolve; + PyObject *__pyx_n_s_Benders_benderspresubsolve; + PyObject *__pyx_n_s_Benders_benderssolvesub; + PyObject *__pyx_n_s_Benders_benderssolvesubconvex; + PyObject *__pyx_n_s_Benderscut; + PyObject *__pyx_n_s_Benderscut___reduce_cython; + PyObject *__pyx_n_s_Benderscut___setstate_cython; + PyObject *__pyx_n_s_Benderscut_benderscutexec; + PyObject *__pyx_n_s_Benderscut_benderscutexit; + PyObject *__pyx_n_s_Benderscut_benderscutexitsol; + PyObject *__pyx_n_s_Benderscut_benderscutfree; + PyObject *__pyx_n_s_Benderscut_benderscutinit; + PyObject *__pyx_n_s_Benderscut_benderscutinitsol; + PyObject *__pyx_n_s_BoundChange; + PyObject *__pyx_n_s_BoundChange___reduce_cython; + PyObject *__pyx_n_s_BoundChange___setstate_cython; + PyObject *__pyx_n_s_BoundChange_getBoundchgtype; + PyObject *__pyx_n_s_BoundChange_getBoundtype; + PyObject *__pyx_n_s_BoundChange_getNewBound; + PyObject *__pyx_n_s_BoundChange_getVar; + PyObject *__pyx_n_s_BoundChange_isRedundant; + PyObject *__pyx_n_s_Branchrule; + PyObject *__pyx_n_s_Branchrule___reduce_cython; + PyObject *__pyx_n_s_Branchrule___setstate_cython; + PyObject *__pyx_n_s_Branchrule_branchexecext; + PyObject *__pyx_n_s_Branchrule_branchexeclp; + PyObject *__pyx_n_s_Branchrule_branchexecps; + PyObject *__pyx_n_s_Branchrule_branchexit; + PyObject *__pyx_n_s_Branchrule_branchexitsol; + PyObject *__pyx_n_s_Branchrule_branchfree; + PyObject *__pyx_n_s_Branchrule_branchinit; + PyObject *__pyx_n_s_Branchrule_branchinitsol; + PyObject *__pyx_n_u_C; + PyObject *__pyx_n_s_CHECK; + PyObject *__pyx_n_s_CHILD; + PyObject *__pyx_n_s_CONS; + PyObject *__pyx_n_s_CONSADDED; + PyObject *__pyx_n_s_CONSCHANGED; + PyObject *__pyx_n_s_CONST; + PyObject *__pyx_n_u_CONTINUOUS; + PyObject *__pyx_n_s_COUNTER; + PyObject *__pyx_n_s_CPSOLVER; + PyObject *__pyx_n_s_CUTOFF; + PyObject *__pyx_kp_u_Can_only_support_constraints_wit; + PyObject *__pyx_kp_u_Can_t_evaluate_constraints_as_bo; + PyObject *__pyx_kp_u_Cannot_set_value_to_a_freed_solu; + PyObject *__pyx_n_u_CardinalityCons; + PyObject *__pyx_n_s_Column; + PyObject *__pyx_n_s_Column___reduce_cython; + PyObject *__pyx_n_s_Column___setstate_cython; + PyObject *__pyx_n_s_Column_getBasisStatus; + PyObject *__pyx_n_s_Column_getLPPos; + PyObject *__pyx_n_s_Column_getLb; + PyObject *__pyx_n_s_Column_getObjCoeff; + PyObject *__pyx_n_s_Column_getPrimsol; + PyObject *__pyx_n_s_Column_getUb; + PyObject *__pyx_n_s_Column_getVar; + PyObject *__pyx_n_s_Column_isIntegral; + PyObject *__pyx_n_s_Conshdlr; + PyObject *__pyx_n_s_Conshdlr___reduce_cython; + PyObject *__pyx_n_s_Conshdlr___setstate_cython; + PyObject *__pyx_n_s_Conshdlr_consactive; + PyObject *__pyx_n_s_Conshdlr_conscheck; + PyObject *__pyx_n_s_Conshdlr_conscopy; + PyObject *__pyx_n_s_Conshdlr_consdeactive; + PyObject *__pyx_n_s_Conshdlr_consdelete; + PyObject *__pyx_n_s_Conshdlr_consdelvars; + PyObject *__pyx_n_s_Conshdlr_consdisable; + PyObject *__pyx_n_s_Conshdlr_consenable; + PyObject *__pyx_n_s_Conshdlr_consenfolp; + PyObject *__pyx_n_s_Conshdlr_consenfops; + PyObject *__pyx_n_s_Conshdlr_consenforelax; + PyObject *__pyx_n_s_Conshdlr_consexit; + PyObject *__pyx_n_s_Conshdlr_consexitpre; + PyObject *__pyx_n_s_Conshdlr_consexitsol; + PyObject *__pyx_n_s_Conshdlr_consfree; + PyObject *__pyx_n_s_Conshdlr_consgetdivebdchgs; + PyObject *__pyx_n_s_Conshdlr_consgetnvars; + PyObject *__pyx_n_s_Conshdlr_consgetpermsymgraph; + PyObject *__pyx_n_s_Conshdlr_consgetsignedpermsymgra; + PyObject *__pyx_n_s_Conshdlr_consgetvars; + PyObject *__pyx_n_s_Conshdlr_consinit; + PyObject *__pyx_n_s_Conshdlr_consinitlp; + PyObject *__pyx_n_s_Conshdlr_consinitpre; + PyObject *__pyx_n_s_Conshdlr_consinitsol; + PyObject *__pyx_n_s_Conshdlr_conslock; + PyObject *__pyx_n_s_Conshdlr_consparse; + PyObject *__pyx_n_s_Conshdlr_conspresol; + PyObject *__pyx_n_s_Conshdlr_consprint; + PyObject *__pyx_n_s_Conshdlr_consprop; + PyObject *__pyx_n_s_Conshdlr_consresprop; + PyObject *__pyx_n_s_Conshdlr_conssepalp; + PyObject *__pyx_n_s_Conshdlr_conssepasol; + PyObject *__pyx_n_s_Conshdlr_constrans; + PyObject *__pyx_n_s_Constant; + PyObject *__pyx_n_s_Constant___reduce_cython; + PyObject *__pyx_n_s_Constant___setstate_cython; + PyObject *__pyx_kp_u_Constant_offsets_in_objective_ar; + PyObject *__pyx_n_s_Constraint; + PyObject *__pyx_n_s_Constraint___reduce_cython; + PyObject *__pyx_n_s_Constraint___setstate_cython; + PyObject *__pyx_n_s_Constraint_getConshdlrName; + PyObject *__pyx_n_s_Constraint_isActive; + PyObject *__pyx_n_s_Constraint_isChecked; + PyObject *__pyx_n_s_Constraint_isDynamic; + PyObject *__pyx_n_s_Constraint_isEnforced; + PyObject *__pyx_n_s_Constraint_isInitial; + PyObject *__pyx_n_s_Constraint_isLinear; + PyObject *__pyx_n_s_Constraint_isLocal; + PyObject *__pyx_n_s_Constraint_isModifiable; + PyObject *__pyx_n_s_Constraint_isNonlinear; + PyObject *__pyx_n_s_Constraint_isOriginal; + PyObject *__pyx_n_s_Constraint_isPropagated; + PyObject *__pyx_n_s_Constraint_isRemovable; + PyObject *__pyx_n_s_Constraint_isSeparated; + PyObject *__pyx_n_s_Constraint_isStickingAtNode; + PyObject *__pyx_n_s_Cutsel; + PyObject *__pyx_n_s_Cutsel___reduce_cython; + PyObject *__pyx_n_s_Cutsel___setstate_cython; + PyObject *__pyx_n_s_Cutsel_cutselexit; + PyObject *__pyx_n_s_Cutsel_cutselexitsol; + PyObject *__pyx_n_s_Cutsel_cutselfree; + PyObject *__pyx_n_s_Cutsel_cutselinit; + PyObject *__pyx_n_s_Cutsel_cutselinitsol; + PyObject *__pyx_n_s_Cutsel_cutselselect; + PyObject *__pyx_n_s_DEADEND; + PyObject *__pyx_n_s_DEFAULT; + PyObject *__pyx_n_s_DELAYED; + PyObject *__pyx_n_s_DIDNOTFIND; + PyObject *__pyx_n_s_DIDNOTRUN; + PyObject *__pyx_n_s_DISABLED; + PyObject *__pyx_n_s_DOMCHANGED; + PyObject *__pyx_n_s_DOWNWARDS; + PyObject *__pyx_n_s_DUALLIMIT; + PyObject *__pyx_n_s_DURINGLPLOOP; + PyObject *__pyx_n_s_DURINGPRESOLLOOP; + PyObject *__pyx_n_s_DURINGPRICINGLOOP; + PyObject *__pyx_n_s_DomainChanges; + PyObject *__pyx_n_s_DomainChanges___reduce_cython; + PyObject *__pyx_n_s_DomainChanges___setstate_cython; + PyObject *__pyx_n_s_DomainChanges_getBoundchgs; + PyObject *__pyx_n_s_EASYCIP; + PyObject *__pyx_n_s_ERROR; + PyObject *__pyx_n_s_EXHAUSTIVE; + PyObject *__pyx_n_s_EXITPRESOLVE; + PyObject *__pyx_n_s_EXITSOLVE; + PyObject *__pyx_n_s_Event; + PyObject *__pyx_n_s_EventNames; + PyObject *__pyx_n_s_Event___reduce_cython; + PyObject *__pyx_n_s_Event___setstate_cython; + PyObject *__pyx_n_s_Event__getEventNames; + PyObject *__pyx_n_s_Event_getName; + PyObject *__pyx_n_s_Event_getNewBound; + PyObject *__pyx_n_s_Event_getNode; + PyObject *__pyx_n_s_Event_getOldBound; + PyObject *__pyx_n_s_Event_getRow; + PyObject *__pyx_n_s_Event_getType; + PyObject *__pyx_n_s_Event_getVar; + PyObject *__pyx_n_s_Eventhdlr; + PyObject *__pyx_n_s_Eventhdlr___reduce_cython; + PyObject *__pyx_n_s_Eventhdlr___setstate_cython; + PyObject *__pyx_n_s_Eventhdlr_eventcopy; + PyObject *__pyx_n_s_Eventhdlr_eventdelete; + PyObject *__pyx_n_s_Eventhdlr_eventexec; + PyObject *__pyx_n_s_Eventhdlr_eventexit; + PyObject *__pyx_n_s_Eventhdlr_eventexitsol; + PyObject *__pyx_n_s_Eventhdlr_eventfree; + PyObject *__pyx_n_s_Eventhdlr_eventinit; + PyObject *__pyx_n_s_Eventhdlr_eventinitsol; + PyObject *__pyx_n_s_Expr; + PyObject *__pyx_kp_u_ExprCons; + PyObject *__pyx_n_s_ExprCons_2; + PyObject *__pyx_n_s_ExprCons___reduce_cython; + PyObject *__pyx_n_s_ExprCons___setstate_cython; + PyObject *__pyx_kp_u_ExprCons_already_has_lower_bound; + PyObject *__pyx_kp_u_ExprCons_already_has_upper_bound; + PyObject *__pyx_n_s_ExprCons_normalize; + PyObject *__pyx_n_s_Expr___reduce_cython; + PyObject *__pyx_n_s_Expr___setstate_cython; + PyObject *__pyx_n_s_Expr_degree; + PyObject *__pyx_n_s_Expr_normalize; + PyObject *__pyx_kp_u_Expr_s; + PyObject *__pyx_n_s_FAST; + PyObject *__pyx_n_s_FEASIBILITY; + PyObject *__pyx_n_s_FEASIBLE; + PyObject *__pyx_n_s_FIRSTLPSOLVED; + PyObject *__pyx_n_s_FIXED; + PyObject *__pyx_n_s_FOCUSNODE; + PyObject *__pyx_n_s_FORK; + PyObject *__pyx_n_s_FOUNDSOL; + PyObject *__pyx_n_s_FREE; + PyObject *__pyx_n_s_FREETRANS; + PyObject *__pyx_n_s_GAPLIMIT; + PyObject *__pyx_n_s_GBDCHANGED; + PyObject *__pyx_n_s_GHOLEADDED; + PyObject *__pyx_n_s_GHOLECHANGED; + PyObject *__pyx_n_s_GHOLEREMOVED; + PyObject *__pyx_n_s_GLBCHANGED; + PyObject *__pyx_n_s_GUBCHANGED; + PyObject *__pyx_n_s_GenExpr; + PyObject *__pyx_n_s_GenExpr___reduce_cython; + PyObject *__pyx_n_s_GenExpr___setstate_cython; + PyObject *__pyx_n_s_GenExpr_degree; + PyObject *__pyx_n_s_GenExpr_getOp; + PyObject *__pyx_kp_u_Given_constraint_list_is_not_ite; + PyObject *__pyx_kp_u_Given_constraint_list_is_not_ite_2; + PyObject *__pyx_n_s_HARDLP; + PyObject *__pyx_n_s_HOLECHANGED; + PyObject *__pyx_n_s_Heur; + PyObject *__pyx_n_s_Heur___reduce_cython; + PyObject *__pyx_n_s_Heur___setstate_cython; + PyObject *__pyx_n_s_Heur_heurexec; + PyObject *__pyx_n_s_Heur_heurexit; + PyObject *__pyx_n_s_Heur_heurexitsol; + PyObject *__pyx_n_s_Heur_heurfree; + PyObject *__pyx_n_s_Heur_heurinit; + PyObject *__pyx_n_s_Heur_heurinitsol; + PyObject *__pyx_n_u_I; + PyObject *__pyx_n_s_IMPLADDED; + PyObject *__pyx_n_u_IMPLINT; + PyObject *__pyx_n_s_INFEASIBLE; + PyObject *__pyx_n_s_INFORUNBD; + PyObject *__pyx_n_s_INIT; + PyObject *__pyx_n_s_INITPRESOLVE; + PyObject *__pyx_n_s_INITSOLVE; + PyObject *__pyx_n_u_INTEGER; + PyObject *__pyx_n_s_IOError; + PyObject *__pyx_n_s_ITERLIMIT; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_7; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_8; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_9; + PyObject *__pyx_n_u_IndicatorCons; + PyObject *__pyx_n_s_Iterable; + PyObject *__pyx_n_s_JUNCTION; + PyObject *__pyx_n_s_KeyError; + PyObject *__pyx_n_s_LBCHANGED; + PyObject *__pyx_n_s_LBRELAXED; + PyObject *__pyx_n_s_LBTIGHTENED; + PyObject *__pyx_n_s_LC_NUMERIC; + PyObject *__pyx_n_s_LEAF; + PyObject *__pyx_n_s_LHOLEADDED; + PyObject *__pyx_n_s_LHOLECHANGED; + PyObject *__pyx_n_s_LHOLEREMOVED; + PyObject *__pyx_n_s_LP; + PyObject *__pyx_n_u_LP; + PyObject *__pyx_n_s_LPEVENT; + PyObject *__pyx_n_s_LPSOLVED; + PyObject *__pyx_n_s_LP___reduce_cython; + PyObject *__pyx_n_s_LP___setstate_cython; + PyObject *__pyx_n_s_LP_addCol; + PyObject *__pyx_n_s_LP_addCols; + PyObject *__pyx_n_s_LP_addRow; + PyObject *__pyx_n_s_LP_addRows; + PyObject *__pyx_n_s_LP_chgBound; + PyObject *__pyx_n_s_LP_chgCoef; + PyObject *__pyx_n_s_LP_chgObj; + PyObject *__pyx_n_s_LP_chgSide; + PyObject *__pyx_n_s_LP_clear; + PyObject *__pyx_n_s_LP_delCols; + PyObject *__pyx_n_s_LP_delRows; + PyObject *__pyx_n_s_LP_getBasisInds; + PyObject *__pyx_n_s_LP_getBounds; + PyObject *__pyx_n_s_LP_getDual; + PyObject *__pyx_n_s_LP_getDualRay; + PyObject *__pyx_n_s_LP_getNIterations; + PyObject *__pyx_n_s_LP_getPrimal; + PyObject *__pyx_n_s_LP_getPrimalRay; + PyObject *__pyx_n_s_LP_getRedcost; + PyObject *__pyx_n_s_LP_getSides; + PyObject *__pyx_n_s_LP_infinity; + PyObject *__pyx_n_s_LP_isDualFeasible; + PyObject *__pyx_n_s_LP_isInfinity; + PyObject *__pyx_n_s_LP_isPrimalFeasible; + PyObject *__pyx_kp_u_LP_lp; + PyObject *__pyx_n_s_LP_ncols; + PyObject *__pyx_n_s_LP_nrows; + PyObject *__pyx_n_s_LP_readLP; + PyObject *__pyx_n_s_LP_solve; + PyObject *__pyx_n_s_LP_writeLP; + PyObject *__pyx_n_s_LookupError; + PyObject *__pyx_n_u_M; + PyObject *__pyx_n_s_MAJOR; + PyObject *__pyx_n_s_MEDIUM; + PyObject *__pyx_n_s_MEMLIMIT; + PyObject *__pyx_n_s_MINOR; + PyObject *__pyx_n_s_MemoryError; + PyObject *__pyx_n_s_Model; + PyObject *__pyx_n_s_Model___reduce_cython; + PyObject *__pyx_n_s_Model___setstate_cython; + PyObject *__pyx_n_s_Model__createConsGenNonlinear; + PyObject *__pyx_n_s_Model__createConsLinear; + PyObject *__pyx_n_s_Model__createConsNonlinear; + PyObject *__pyx_n_s_Model__createConsQuadratic; + PyObject *__pyx_n_s_Model__getStageNames; + PyObject *__pyx_n_s_Model_activateBenders; + PyObject *__pyx_n_s_Model_addBendersSubproblem; + PyObject *__pyx_n_s_Model_addCoefLinear; + PyObject *__pyx_n_s_Model_addCons; + PyObject *__pyx_n_s_Model_addConsAnd; + PyObject *__pyx_n_s_Model_addConsCardinality; + PyObject *__pyx_n_s_Model_addConsCoeff; + PyObject *__pyx_n_s_Model_addConsDisjunction; + PyObject *__pyx_n_s_Model_addConsElemDisjunction; + PyObject *__pyx_n_s_Model_addConsIndicator; + PyObject *__pyx_n_s_Model_addConsLocal; + PyObject *__pyx_n_s_Model_addConsNode; + PyObject *__pyx_n_s_Model_addConsOr; + PyObject *__pyx_n_s_Model_addConsSOS1; + PyObject *__pyx_n_s_Model_addConsSOS2; + PyObject *__pyx_n_s_Model_addConsXor; + PyObject *__pyx_n_s_Model_addConss; + PyObject *__pyx_n_s_Model_addCut; + PyObject *__pyx_n_s_Model_addExprNonlinear; + PyObject *__pyx_n_s_Model_addObjoffset; + PyObject *__pyx_n_s_Model_addPoolCut; + PyObject *__pyx_n_s_Model_addPyCons; + PyObject *__pyx_n_s_Model_addRowDive; + PyObject *__pyx_n_s_Model_addSol; + PyObject *__pyx_n_s_Model_addVar; + PyObject *__pyx_n_s_Model_addVarLocks; + PyObject *__pyx_n_s_Model_addVarSOS1; + PyObject *__pyx_n_s_Model_addVarSOS2; + PyObject *__pyx_n_s_Model_addVarToRow; + PyObject *__pyx_n_s_Model_appendVarSOS1; + PyObject *__pyx_n_s_Model_appendVarSOS2; + PyObject *__pyx_n_s_Model_applyCutsProbing; + PyObject *__pyx_n_s_Model_backtrackProbing; + PyObject *__pyx_n_s_Model_branchVar; + PyObject *__pyx_n_s_Model_branchVarVal; + PyObject *__pyx_n_s_Model_cacheRowExtensions; + PyObject *__pyx_n_s_Model_calcChildEstimate; + PyObject *__pyx_n_s_Model_calcNodeselPriority; + PyObject *__pyx_n_s_Model_catchEvent; + PyObject *__pyx_n_s_Model_catchRowEvent; + PyObject *__pyx_n_s_Model_catchVarEvent; + PyObject *__pyx_n_s_Model_checkBendersSubproblemOpti; + PyObject *__pyx_n_s_Model_checkQuadraticNonlinear; + PyObject *__pyx_n_s_Model_checkSol; + PyObject *__pyx_n_s_Model_chgCoefLinear; + PyObject *__pyx_n_s_Model_chgLhs; + PyObject *__pyx_n_s_Model_chgReoptObjective; + PyObject *__pyx_n_s_Model_chgRhs; + PyObject *__pyx_n_s_Model_chgRowLhsDive; + PyObject *__pyx_n_s_Model_chgRowRhsDive; + PyObject *__pyx_n_s_Model_chgVarBranchPriority; + PyObject *__pyx_n_s_Model_chgVarLb; + PyObject *__pyx_n_s_Model_chgVarLbDive; + PyObject *__pyx_n_s_Model_chgVarLbGlobal; + PyObject *__pyx_n_s_Model_chgVarLbNode; + PyObject *__pyx_n_s_Model_chgVarLbProbing; + PyObject *__pyx_n_s_Model_chgVarObjDive; + PyObject *__pyx_n_s_Model_chgVarObjProbing; + PyObject *__pyx_n_s_Model_chgVarType; + PyObject *__pyx_n_s_Model_chgVarUb; + PyObject *__pyx_n_s_Model_chgVarUbDive; + PyObject *__pyx_n_s_Model_chgVarUbGlobal; + PyObject *__pyx_n_s_Model_chgVarUbNode; + PyObject *__pyx_n_s_Model_chgVarUbProbing; + PyObject *__pyx_n_s_Model_computeBestSolSubproblems; + PyObject *__pyx_n_s_Model_constructLP; + PyObject *__pyx_n_s_Model_count; + PyObject *__pyx_n_s_Model_createChild; + PyObject *__pyx_n_s_Model_createCons; + PyObject *__pyx_n_s_Model_createConsFromExpr; + PyObject *__pyx_n_s_Model_createEmptyRowSepa; + PyObject *__pyx_n_s_Model_createEmptyRowUnspec; + PyObject *__pyx_n_s_Model_createOrigSol; + PyObject *__pyx_n_s_Model_createPartialSol; + PyObject *__pyx_n_s_Model_createProbBasic; + PyObject *__pyx_n_s_Model_createSol; + PyObject *__pyx_n_s_Model_delCoefLinear; + PyObject *__pyx_n_s_Model_delCons; + PyObject *__pyx_n_s_Model_delConsLocal; + PyObject *__pyx_n_s_Model_delVar; + PyObject *__pyx_n_s_Model_disablePropagation; + PyObject *__pyx_n_s_Model_dropEvent; + PyObject *__pyx_n_s_Model_dropRowEvent; + PyObject *__pyx_n_s_Model_dropVarEvent; + PyObject *__pyx_n_s_Model_enableReoptimization; + PyObject *__pyx_n_s_Model_endDive; + PyObject *__pyx_n_s_Model_endProbing; + PyObject *__pyx_n_s_Model_epsilon; + PyObject *__pyx_n_s_Model_feasFrac; + PyObject *__pyx_n_s_Model_feastol; + PyObject *__pyx_n_s_Model_fixVar; + PyObject *__pyx_n_s_Model_fixVarProbing; + PyObject *__pyx_n_s_Model_flushRowExtensions; + PyObject *__pyx_n_s_Model_frac; + PyObject *__pyx_n_s_Model_freeBendersSubproblems; + PyObject *__pyx_n_s_Model_freeProb; + PyObject *__pyx_n_s_Model_freeReoptSolve; + PyObject *__pyx_n_s_Model_freeSol; + PyObject *__pyx_n_s_Model_freeTransform; + PyObject *__pyx_n_s_Model_from_ptr; + PyObject *__pyx_n_s_Model_getActivity; + PyObject *__pyx_n_s_Model_getBendersAuxiliaryVar; + PyObject *__pyx_n_s_Model_getBendersSubproblem; + PyObject *__pyx_n_s_Model_getBendersVar; + PyObject *__pyx_n_s_Model_getBestChild; + PyObject *__pyx_n_s_Model_getBestLeaf; + PyObject *__pyx_n_s_Model_getBestNode; + PyObject *__pyx_n_s_Model_getBestSibling; + PyObject *__pyx_n_s_Model_getBestSol; + PyObject *__pyx_n_s_Model_getBestboundNode; + PyObject *__pyx_n_s_Model_getCondition; + PyObject *__pyx_n_s_Model_getConsNVars; + PyObject *__pyx_n_s_Model_getConsVars; + PyObject *__pyx_n_s_Model_getConss; + PyObject *__pyx_n_s_Model_getCurrentNode; + PyObject *__pyx_n_s_Model_getCutEfficacy; + PyObject *__pyx_n_s_Model_getCutLPSolCutoffDistance; + PyObject *__pyx_n_s_Model_getDepth; + PyObject *__pyx_n_s_Model_getDualMultiplier; + PyObject *__pyx_n_s_Model_getDualSolVal; + PyObject *__pyx_n_s_Model_getDualbound; + PyObject *__pyx_n_s_Model_getDualboundRoot; + PyObject *__pyx_n_s_Model_getDualfarkasLinear; + PyObject *__pyx_n_s_Model_getDualsolLinear; + PyObject *__pyx_n_s_Model_getGap; + PyObject *__pyx_n_s_Model_getLPBInvARow; + PyObject *__pyx_n_s_Model_getLPBInvRow; + PyObject *__pyx_n_s_Model_getLPBasisInd; + PyObject *__pyx_n_s_Model_getLPBranchCands; + PyObject *__pyx_n_s_Model_getLPColsData; + PyObject *__pyx_n_s_Model_getLPObjVal; + PyObject *__pyx_n_s_Model_getLPRowsData; + PyObject *__pyx_n_s_Model_getLPSolstat; + PyObject *__pyx_n_s_Model_getLhs; + PyObject *__pyx_n_s_Model_getLocalEstimate; + PyObject *__pyx_n_s_Model_getNBestSolsFound; + PyObject *__pyx_n_s_Model_getNBinVars; + PyObject *__pyx_n_s_Model_getNChildren; + PyObject *__pyx_n_s_Model_getNConss; + PyObject *__pyx_n_s_Model_getNCountedSols; + PyObject *__pyx_n_s_Model_getNCuts; + PyObject *__pyx_n_s_Model_getNCutsApplied; + PyObject *__pyx_n_s_Model_getNFeasibleLeaves; + PyObject *__pyx_n_s_Model_getNInfeasibleLeaves; + PyObject *__pyx_n_s_Model_getNIntVars; + PyObject *__pyx_n_s_Model_getNLPCols; + PyObject *__pyx_n_s_Model_getNLPIterations; + PyObject *__pyx_n_s_Model_getNLPRows; + PyObject *__pyx_n_s_Model_getNLPs; + PyObject *__pyx_n_s_Model_getNLeaves; + PyObject *__pyx_n_s_Model_getNLimSolsFound; + PyObject *__pyx_n_s_Model_getNNlRows; + PyObject *__pyx_n_s_Model_getNNodes; + PyObject *__pyx_n_s_Model_getNReaders; + PyObject *__pyx_n_s_Model_getNSepaRounds; + PyObject *__pyx_n_s_Model_getNSiblings; + PyObject *__pyx_n_s_Model_getNSols; + PyObject *__pyx_n_s_Model_getNSolsFound; + PyObject *__pyx_n_s_Model_getNTotalNodes; + PyObject *__pyx_n_s_Model_getNVars; + PyObject *__pyx_n_s_Model_getNlRowActivityBounds; + PyObject *__pyx_n_s_Model_getNlRowSolActivity; + PyObject *__pyx_n_s_Model_getNlRowSolFeasibility; + PyObject *__pyx_n_s_Model_getNlRows; + PyObject *__pyx_n_s_Model_getObjVal; + PyObject *__pyx_n_s_Model_getObjective; + PyObject *__pyx_n_s_Model_getObjectiveSense; + PyObject *__pyx_n_s_Model_getObjlimit; + PyObject *__pyx_n_s_Model_getObjoffset; + PyObject *__pyx_n_s_Model_getOpenNodes; + PyObject *__pyx_n_s_Model_getParam; + PyObject *__pyx_n_s_Model_getParams; + PyObject *__pyx_n_s_Model_getPresolvingTime; + PyObject *__pyx_n_s_Model_getPrimalRay; + PyObject *__pyx_n_s_Model_getPrimalRayVal; + PyObject *__pyx_n_s_Model_getPrimalbound; + PyObject *__pyx_n_s_Model_getProbName; + PyObject *__pyx_n_s_Model_getProbingDepth; + PyObject *__pyx_n_s_Model_getPseudoBranchCands; + PyObject *__pyx_n_s_Model_getReadingTime; + PyObject *__pyx_n_s_Model_getRhs; + PyObject *__pyx_n_s_Model_getRowActivity; + PyObject *__pyx_n_s_Model_getRowDualSol; + PyObject *__pyx_n_s_Model_getRowLPActivity; + PyObject *__pyx_n_s_Model_getRowLinear; + PyObject *__pyx_n_s_Model_getRowNumIntCols; + PyObject *__pyx_n_s_Model_getRowObjParallelism; + PyObject *__pyx_n_s_Model_getRowParallelism; + PyObject *__pyx_n_s_Model_getSlack; + PyObject *__pyx_n_s_Model_getSlackVarIndicator; + PyObject *__pyx_n_s_Model_getSolObjVal; + PyObject *__pyx_n_s_Model_getSolTime; + PyObject *__pyx_n_s_Model_getSolVal; + PyObject *__pyx_n_s_Model_getSols; + PyObject *__pyx_n_s_Model_getSolvingTime; + PyObject *__pyx_n_s_Model_getStage; + PyObject *__pyx_n_s_Model_getStageName; + PyObject *__pyx_n_s_Model_getStatus; + PyObject *__pyx_n_s_Model_getTermsQuadratic; + PyObject *__pyx_n_s_Model_getTotalTime; + PyObject *__pyx_n_s_Model_getTransformedCons; + PyObject *__pyx_n_s_Model_getTransformedVar; + PyObject *__pyx_n_s_Model_getTreesizeEstimation; + PyObject *__pyx_n_s_Model_getVal; + PyObject *__pyx_n_s_Model_getValsLinear; + PyObject *__pyx_n_s_Model_getVarDict; + PyObject *__pyx_n_s_Model_getVarLbDive; + PyObject *__pyx_n_s_Model_getVarRedcost; + PyObject *__pyx_n_s_Model_getVarUbDive; + PyObject *__pyx_n_s_Model_getVars; + PyObject *__pyx_n_s_Model_hasPrimalRay; + PyObject *__pyx_n_s_Model_hideOutput; + PyObject *__pyx_n_s_Model_inProbing; + PyObject *__pyx_n_s_Model_inRepropagation; + PyObject *__pyx_n_s_Model_includeBenders; + PyObject *__pyx_n_s_Model_includeBendersDefaultCuts; + PyObject *__pyx_n_s_Model_includeBenderscut; + PyObject *__pyx_n_s_Model_includeBranchrule; + PyObject *__pyx_n_s_Model_includeConshdlr; + PyObject *__pyx_n_s_Model_includeCutsel; + PyObject *__pyx_n_s_Model_includeDefaultPlugins; + PyObject *__pyx_n_s_Model_includeEventhdlr; + PyObject *__pyx_n_s_Model_includeHeur; + PyObject *__pyx_n_s_Model_includeNodesel; + PyObject *__pyx_n_s_Model_includePresol; + PyObject *__pyx_n_s_Model_includePricer; + PyObject *__pyx_n_s_Model_includeProp; + PyObject *__pyx_n_s_Model_includeReader; + PyObject *__pyx_n_s_Model_includeRelax; + PyObject *__pyx_n_s_Model_includeSepa; + PyObject *__pyx_n_s_Model_infinity; + PyObject *__pyx_n_s_Model_initBendersDefault; + PyObject *__pyx_n_s_Model_interruptSolve; + PyObject *__pyx_n_s_Model_isCutEfficacious; + PyObject *__pyx_n_s_Model_isEQ; + PyObject *__pyx_n_s_Model_isFeasEQ; + PyObject *__pyx_n_s_Model_isFeasIntegral; + PyObject *__pyx_n_s_Model_isFeasNegative; + PyObject *__pyx_n_s_Model_isFeasZero; + PyObject *__pyx_n_s_Model_isGE; + PyObject *__pyx_n_s_Model_isGT; + PyObject *__pyx_n_s_Model_isInfinity; + PyObject *__pyx_n_s_Model_isLE; + PyObject *__pyx_n_s_Model_isLPSolBasic; + PyObject *__pyx_n_s_Model_isLT; + PyObject *__pyx_n_s_Model_isNLPConstructed; + PyObject *__pyx_n_s_Model_isObjChangedProbing; + PyObject *__pyx_n_s_Model_isZero; + PyObject *__pyx_n_s_Model_lpiGetIterations; + PyObject *__pyx_n_s_Model_newProbingNode; + PyObject *__pyx_n_s_Model_optimize; + PyObject *__pyx_n_s_Model_presolve; + PyObject *__pyx_n_s_Model_printBestSol; + PyObject *__pyx_n_s_Model_printCons; + PyObject *__pyx_n_s_Model_printExternalCodeVersions; + PyObject *__pyx_n_s_Model_printNlRow; + PyObject *__pyx_n_s_Model_printRow; + PyObject *__pyx_n_s_Model_printSol; + PyObject *__pyx_n_s_Model_printStatistics; + PyObject *__pyx_n_s_Model_printVersion; + PyObject *__pyx_n_s_Model_propagateProbing; + PyObject *__pyx_n_s_Model_readParams; + PyObject *__pyx_n_s_Model_readProblem; + PyObject *__pyx_n_s_Model_readSol; + PyObject *__pyx_n_s_Model_readSolFile; + PyObject *__pyx_n_s_Model_redirectOutput; + PyObject *__pyx_n_s_Model_relax; + PyObject *__pyx_n_s_Model_releaseRow; + PyObject *__pyx_n_s_Model_repropagateNode; + PyObject *__pyx_n_s_Model_resetParam; + PyObject *__pyx_n_s_Model_resetParams; + PyObject *__pyx_n_s_Model_restartSolve; + PyObject *__pyx_n_s_Model_separateSol; + PyObject *__pyx_n_s_Model_setBendersSubproblemIsConv; + PyObject *__pyx_n_s_Model_setBoolParam; + PyObject *__pyx_n_s_Model_setCharParam; + PyObject *__pyx_n_s_Model_setCheck; + PyObject *__pyx_n_s_Model_setEmphasis; + PyObject *__pyx_n_s_Model_setEnforced; + PyObject *__pyx_n_s_Model_setHeuristics; + PyObject *__pyx_n_s_Model_setInitial; + PyObject *__pyx_n_s_Model_setIntParam; + PyObject *__pyx_n_s_Model_setLogfile; + PyObject *__pyx_n_s_Model_setLongintParam; + PyObject *__pyx_n_s_Model_setMaximize; + PyObject *__pyx_n_s_Model_setMinimize; + PyObject *__pyx_n_s_Model_setObjIntegral; + PyObject *__pyx_n_s_Model_setObjective; + PyObject *__pyx_n_s_Model_setObjlimit; + PyObject *__pyx_n_s_Model_setParam; + PyObject *__pyx_n_s_Model_setParams; + PyObject *__pyx_n_s_Model_setParamsCountsols; + PyObject *__pyx_n_s_Model_setPresolve; + PyObject *__pyx_n_s_Model_setProbName; + PyObject *__pyx_n_s_Model_setRealParam; + PyObject *__pyx_n_s_Model_setRelaxSolVal; + PyObject *__pyx_n_s_Model_setRemovable; + PyObject *__pyx_n_s_Model_setSeparating; + PyObject *__pyx_n_s_Model_setSolVal; + PyObject *__pyx_n_s_Model_setStringParam; + PyObject *__pyx_n_s_Model_setupBendersSubproblem; + PyObject *__pyx_n_s_Model_solveBendersSubproblem; + PyObject *__pyx_n_s_Model_solveConcurrent; + PyObject *__pyx_n_s_Model_solveDiveLP; + PyObject *__pyx_n_s_Model_solveProbingLP; + PyObject *__pyx_n_s_Model_startDive; + PyObject *__pyx_n_s_Model_startProbing; + PyObject *__pyx_n_s_Model_tightenVarLb; + PyObject *__pyx_n_s_Model_tightenVarLbGlobal; + PyObject *__pyx_n_s_Model_tightenVarUb; + PyObject *__pyx_n_s_Model_tightenVarUbGlobal; + PyObject *__pyx_n_s_Model_to_ptr; + PyObject *__pyx_n_s_Model_trySol; + PyObject *__pyx_n_s_Model_updateBendersLowerbounds; + PyObject *__pyx_n_s_Model_updateNodeLowerbound; + PyObject *__pyx_n_s_Model_version; + PyObject *__pyx_n_s_Model_writeBestSol; + PyObject *__pyx_n_s_Model_writeBestTransSol; + PyObject *__pyx_n_s_Model_writeLP; + PyObject *__pyx_n_s_Model_writeName; + PyObject *__pyx_n_s_Model_writeParams; + PyObject *__pyx_n_s_Model_writeProblem; + PyObject *__pyx_n_s_Model_writeSol; + PyObject *__pyx_n_s_Model_writeStatistics; + PyObject *__pyx_n_s_Model_writeTransSol; + PyObject *__pyx_n_s_NEWROUND; + PyObject *__pyx_n_s_NLRow; + PyObject *__pyx_n_s_NLRow___reduce_cython; + PyObject *__pyx_n_s_NLRow___setstate_cython; + PyObject *__pyx_n_s_NLRow_getConstant; + PyObject *__pyx_n_s_NLRow_getDualsol; + PyObject *__pyx_n_s_NLRow_getLhs; + PyObject *__pyx_n_s_NLRow_getLinearTerms; + PyObject *__pyx_n_s_NLRow_getRhs; + PyObject *__pyx_n_s_NODEBRANCHED; + PyObject *__pyx_n_s_NODEDELETE; + PyObject *__pyx_n_s_NODEEVENT; + PyObject *__pyx_n_s_NODEFEASIBLE; + PyObject *__pyx_n_s_NODEFOCUSED; + PyObject *__pyx_n_s_NODEINFEASIBLE; + PyObject *__pyx_n_s_NODELIMIT; + PyObject *__pyx_n_s_NODESOLVED; + PyObject *__pyx_n_s_NONE; + PyObject *__pyx_n_s_NOTSOLVED; + PyObject *__pyx_n_s_NUMERICS; + PyObject *__pyx_n_s_Node; + PyObject *__pyx_n_s_Node___reduce_cython; + PyObject *__pyx_n_s_Node___setstate_cython; + PyObject *__pyx_n_s_Node_getAddedConss; + PyObject *__pyx_n_s_Node_getDepth; + PyObject *__pyx_n_s_Node_getDomchg; + PyObject *__pyx_n_s_Node_getEstimate; + PyObject *__pyx_n_s_Node_getLowerbound; + PyObject *__pyx_n_s_Node_getNAddedConss; + PyObject *__pyx_n_s_Node_getNDomchg; + PyObject *__pyx_n_s_Node_getNParentBranchings; + PyObject *__pyx_n_s_Node_getNumber; + PyObject *__pyx_n_s_Node_getParent; + PyObject *__pyx_n_s_Node_getParentBranchings; + PyObject *__pyx_n_s_Node_getType; + PyObject *__pyx_n_s_Node_isActive; + PyObject *__pyx_n_s_Node_isPropagatedAgain; + PyObject *__pyx_n_s_Nodesel; + PyObject *__pyx_n_s_Nodesel___reduce_cython; + PyObject *__pyx_n_s_Nodesel___setstate_cython; + PyObject *__pyx_n_s_Nodesel_nodecomp; + PyObject *__pyx_n_s_Nodesel_nodeexit; + PyObject *__pyx_n_s_Nodesel_nodeexitsol; + PyObject *__pyx_n_s_Nodesel_nodefree; + PyObject *__pyx_n_s_Nodesel_nodeinit; + PyObject *__pyx_n_s_Nodesel_nodeinitsol; + PyObject *__pyx_n_s_Nodesel_nodeselect; + PyObject *__pyx_kp_u_Nonlinear_objective_functions_ar; + PyObject *__pyx_n_s_NotImplementedError; + PyObject *__pyx_kp_u_Not_a_valid_parameter_name; + PyObject *__pyx_n_s_OBJCHANGED; + PyObject *__pyx_n_s_OBJLIMIT; + PyObject *__pyx_n_s_OFF; + PyObject *__pyx_n_s_OPTIMAL; + PyObject *__pyx_n_s_OPTIMALITY; + PyObject *__pyx_n_u_ORcons; + PyObject *__pyx_n_s_Op; + PyObject *__pyx_n_s_Operator; + PyObject *__pyx_n_s_PATCH; + PyObject *__pyx_n_s_PHASEFEAS; + PyObject *__pyx_n_s_PHASEIMPROVE; + PyObject *__pyx_n_s_PHASEPROOF; + PyObject *__pyx_n_s_POORSOLFOUND; + PyObject *__pyx_n_s_PRESOLVED; + PyObject *__pyx_n_s_PRESOLVEROUND; + PyObject *__pyx_n_s_PRESOLVING; + PyObject *__pyx_n_s_PRIMALLIMIT; + PyObject *__pyx_n_s_PROBINGNODE; + PyObject *__pyx_n_s_PROBLEM; + PyObject *__pyx_n_s_PSEUDO; + PyObject *__pyx_n_s_PSEUDOFORK; + PyObject *__pyx_n_s_PY_SCIP_BENDERSENFOTYPE; + PyObject *__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___reduce; + PyObject *__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___setsta; + PyObject *__pyx_n_s_PY_SCIP_BRANCHDIR; + PyObject *__pyx_n_s_PY_SCIP_BRANCHDIR___reduce_cytho; + PyObject *__pyx_n_s_PY_SCIP_BRANCHDIR___setstate_cyt; + PyObject *__pyx_n_s_PY_SCIP_CALL; + PyObject *__pyx_n_s_PY_SCIP_EVENTTYPE; + PyObject *__pyx_n_s_PY_SCIP_EVENTTYPE___reduce_cytho; + PyObject *__pyx_n_s_PY_SCIP_EVENTTYPE___setstate_cyt; + PyObject *__pyx_n_s_PY_SCIP_HEURTIMING; + PyObject *__pyx_n_s_PY_SCIP_HEURTIMING___reduce_cyth; + PyObject *__pyx_n_s_PY_SCIP_HEURTIMING___setstate_cy; + PyObject *__pyx_n_s_PY_SCIP_LPSOLSTAT; + PyObject *__pyx_n_s_PY_SCIP_LPSOLSTAT___reduce_cytho; + PyObject *__pyx_n_s_PY_SCIP_LPSOLSTAT___setstate_cyt; + PyObject *__pyx_n_s_PY_SCIP_NODETYPE; + PyObject *__pyx_n_s_PY_SCIP_NODETYPE___reduce_cython; + PyObject *__pyx_n_s_PY_SCIP_NODETYPE___setstate_cyth; + PyObject *__pyx_n_s_PY_SCIP_PARAMEMPHASIS; + PyObject *__pyx_n_s_PY_SCIP_PARAMEMPHASIS___reduce_c; + PyObject *__pyx_n_s_PY_SCIP_PARAMEMPHASIS___setstate; + PyObject *__pyx_n_s_PY_SCIP_PARAMSETTING; + PyObject *__pyx_n_s_PY_SCIP_PARAMSETTING___reduce_cy; + PyObject *__pyx_n_s_PY_SCIP_PARAMSETTING___setstate; + PyObject *__pyx_n_s_PY_SCIP_PRESOLTIMING; + PyObject *__pyx_n_s_PY_SCIP_PRESOLTIMING___reduce_cy; + PyObject *__pyx_n_s_PY_SCIP_PRESOLTIMING___setstate; + PyObject *__pyx_n_s_PY_SCIP_PROPTIMING; + PyObject *__pyx_n_s_PY_SCIP_PROPTIMING___reduce_cyth; + PyObject *__pyx_n_s_PY_SCIP_PROPTIMING___setstate_cy; + PyObject *__pyx_n_s_PY_SCIP_RESULT; + PyObject *__pyx_n_s_PY_SCIP_RESULT___reduce_cython; + PyObject *__pyx_n_s_PY_SCIP_RESULT___setstate_cython; + PyObject *__pyx_n_s_PY_SCIP_ROWORIGINTYPE; + PyObject *__pyx_n_s_PY_SCIP_ROWORIGINTYPE___reduce_c; + PyObject *__pyx_n_s_PY_SCIP_ROWORIGINTYPE___setstate; + PyObject *__pyx_n_s_PY_SCIP_STAGE; + PyObject *__pyx_n_s_PY_SCIP_STAGE___reduce_cython; + PyObject *__pyx_n_s_PY_SCIP_STAGE___setstate_cython; + PyObject *__pyx_n_s_PY_SCIP_STATUS; + PyObject *__pyx_n_s_PY_SCIP_STATUS___reduce_cython; + PyObject *__pyx_n_s_PY_SCIP_STATUS___setstate_cython; + PyObject *__pyx_n_s_PickleError; + PyObject *__pyx_n_s_PowExpr; + PyObject *__pyx_n_s_PowExpr___reduce_cython; + PyObject *__pyx_n_s_PowExpr___setstate_cython; + PyObject *__pyx_n_s_Presol; + PyObject *__pyx_n_s_Presol___reduce_cython; + PyObject *__pyx_n_s_Presol___setstate_cython; + PyObject *__pyx_n_s_Presol_presolexec; + PyObject *__pyx_n_s_Presol_presolexit; + PyObject *__pyx_n_s_Presol_presolexitpre; + PyObject *__pyx_n_s_Presol_presolfree; + PyObject *__pyx_n_s_Presol_presolinit; + PyObject *__pyx_n_s_Presol_presolinitpre; + PyObject *__pyx_n_s_Pricer; + PyObject *__pyx_n_s_Pricer___reduce_cython; + PyObject *__pyx_n_s_Pricer___setstate_cython; + PyObject *__pyx_n_s_Pricer_pricerexit; + PyObject *__pyx_n_s_Pricer_pricerexitsol; + PyObject *__pyx_n_s_Pricer_pricerfarkas; + PyObject *__pyx_n_s_Pricer_pricerfree; + PyObject *__pyx_n_s_Pricer_pricerinit; + PyObject *__pyx_n_s_Pricer_pricerinitsol; + PyObject *__pyx_n_s_Pricer_pricerredcost; + PyObject *__pyx_n_s_ProdExpr; + PyObject *__pyx_n_s_ProdExpr___reduce_cython; + PyObject *__pyx_n_s_ProdExpr___setstate_cython; + PyObject *__pyx_n_s_Prop; + PyObject *__pyx_n_s_Prop___reduce_cython; + PyObject *__pyx_n_s_Prop___setstate_cython; + PyObject *__pyx_n_s_Prop_propexec; + PyObject *__pyx_n_s_Prop_propexit; + PyObject *__pyx_n_s_Prop_propexitpre; + PyObject *__pyx_n_s_Prop_propexitsol; + PyObject *__pyx_n_s_Prop_propfree; + PyObject *__pyx_n_s_Prop_propinit; + PyObject *__pyx_n_s_Prop_propinitpre; + PyObject *__pyx_n_s_Prop_propinitsol; + PyObject *__pyx_n_s_Prop_proppresol; + PyObject *__pyx_n_s_Prop_propresprop; + PyObject *__pyx_kp_u_Provide_BOOLEAN_value_as_rhsvar; + PyObject *__pyx_n_s_PyCons; + PyObject *__pyx_n_s_PyRow; + PyObject *__pyx_n_s_REDUCEDDOM; + PyObject *__pyx_n_s_REFOCUSNODE; + PyObject *__pyx_n_s_RELAX; + PyObject *__pyx_n_s_REOPT; + PyObject *__pyx_n_s_RESTARTLIMIT; + PyObject *__pyx_n_s_ROWADDEDLP; + PyObject *__pyx_n_s_ROWADDEDSEPA; + PyObject *__pyx_n_s_ROWCHANGED; + PyObject *__pyx_n_s_ROWCOEFCHANGED; + PyObject *__pyx_n_s_ROWCONSTCHANGED; + PyObject *__pyx_n_s_ROWDELETEDLP; + PyObject *__pyx_n_s_ROWDELETEDSEPA; + PyObject *__pyx_n_s_ROWEVENT; + PyObject *__pyx_n_s_ROWSIDECHANGED; + PyObject *__pyx_kp_u_Ranged_ExprCons_is_not_well_defi; + PyObject *__pyx_n_s_Reader; + PyObject *__pyx_n_s_Reader___reduce_cython; + PyObject *__pyx_n_s_Reader___setstate_cython; + PyObject *__pyx_n_s_Reader_readerfree; + PyObject *__pyx_n_s_Reader_readerread; + PyObject *__pyx_n_s_Reader_readerwrite; + PyObject *__pyx_n_s_Relax; + PyObject *__pyx_n_s_Relax___reduce_cython; + PyObject *__pyx_n_s_Relax___setstate_cython; + PyObject *__pyx_n_s_Relax_relaxexec; + PyObject *__pyx_n_s_Relax_relaxexit; + PyObject *__pyx_n_s_Relax_relaxexitsol; + PyObject *__pyx_n_s_Relax_relaxfree; + PyObject *__pyx_n_s_Relax_relaxinit; + PyObject *__pyx_n_s_Relax_relaxinitsol; + PyObject *__pyx_n_s_Row; + PyObject *__pyx_n_s_Row___reduce_cython; + PyObject *__pyx_n_s_Row___setstate_cython; + PyObject *__pyx_n_s_Row_getBasisStatus; + PyObject *__pyx_n_s_Row_getCols; + PyObject *__pyx_n_s_Row_getConsOriginConshdlrtype; + PyObject *__pyx_n_s_Row_getConstant; + PyObject *__pyx_n_s_Row_getLPPos; + PyObject *__pyx_n_s_Row_getLhs; + PyObject *__pyx_n_s_Row_getNLPNonz; + PyObject *__pyx_n_s_Row_getNNonz; + PyObject *__pyx_n_s_Row_getNorm; + PyObject *__pyx_n_s_Row_getOrigintype; + PyObject *__pyx_n_s_Row_getRhs; + PyObject *__pyx_n_s_Row_getVals; + PyObject *__pyx_n_s_Row_isInGlobalCutpool; + PyObject *__pyx_n_s_Row_isIntegral; + PyObject *__pyx_n_s_Row_isLocal; + PyObject *__pyx_n_s_Row_isModifiable; + PyObject *__pyx_n_s_Row_isRemovable; + PyObject *__pyx_n_s_SCIP_BOUNDTYPE_TO_STRING; + PyObject *__pyx_kp_u_SCIP_a_required_plugin_was_not_f; + PyObject *__pyx_kp_u_SCIP_cannot_create_file; + PyObject *__pyx_kp_u_SCIP_does_not_support_nonlinear; + PyObject *__pyx_kp_u_SCIP_error_in_LP_solver; + PyObject *__pyx_kp_u_SCIP_error_in_input_data; + PyObject *__pyx_kp_u_SCIP_file_not_found_error; + PyObject *__pyx_kp_u_SCIP_insufficient_memory_error; + PyObject *__pyx_kp_u_SCIP_maximal_branching_depth_lev; + PyObject *__pyx_kp_u_SCIP_method_cannot_be_called_at; + PyObject *__pyx_kp_u_SCIP_method_returned_an_invalid; + PyObject *__pyx_kp_u_SCIP_no_problem_exists; + PyObject *__pyx_kp_u_SCIP_read_error; + PyObject *__pyx_kp_u_SCIP_reading_solution_from_file; + PyObject *__pyx_kp_u_SCIP_returned_base_status_zero_f; + PyObject *__pyx_kp_u_SCIP_returned_unknown_base_statu; + PyObject *__pyx_kp_u_SCIP_the_given_key_is_already_ex; + PyObject *__pyx_kp_u_SCIP_the_parameter_is_not_of_the; + PyObject *__pyx_kp_u_SCIP_the_parameter_with_the_give; + PyObject *__pyx_kp_u_SCIP_the_value_is_invalid_for_th; + PyObject *__pyx_kp_u_SCIP_unknown_return_code; + PyObject *__pyx_kp_u_SCIP_unspecified_error; + PyObject *__pyx_kp_u_SCIP_was_compiled_without_task_p; + PyObject *__pyx_kp_u_SCIP_write_error; + PyObject *__pyx_n_u_SCIPgetSolVal; + PyObject *__pyx_n_s_SEPA; + PyObject *__pyx_n_s_SEPARATED; + PyObject *__pyx_n_s_SIBLING; + PyObject *__pyx_n_s_SOLEVENT; + PyObject *__pyx_n_s_SOLFOUND; + PyObject *__pyx_n_s_SOLLIMIT; + PyObject *__pyx_n_s_SOLVED; + PyObject *__pyx_n_s_SOLVELP; + PyObject *__pyx_n_s_SOLVING; + PyObject *__pyx_n_u_SOS1cons; + PyObject *__pyx_n_u_SOS2cons; + PyObject *__pyx_n_s_STALLNODELIMIT; + PyObject *__pyx_n_s_SUBROOT; + PyObject *__pyx_n_s_SUCCESS; + PyObject *__pyx_n_s_SUSPENDED; + PyObject *__pyx_n_s_SYNC; + PyObject *__pyx_n_s_Sepa; + PyObject *__pyx_n_s_Sepa___reduce_cython; + PyObject *__pyx_n_s_Sepa___setstate_cython; + PyObject *__pyx_n_s_Sepa_sepaexeclp; + PyObject *__pyx_n_s_Sepa_sepaexecsol; + PyObject *__pyx_n_s_Sepa_sepaexit; + PyObject *__pyx_n_s_Sepa_sepaexitsol; + PyObject *__pyx_n_s_Sepa_sepafree; + PyObject *__pyx_n_s_Sepa_sepainit; + PyObject *__pyx_n_s_Sepa_sepainitsol; + PyObject *__pyx_n_s_Solution; + PyObject *__pyx_n_s_Solution___reduce_cython; + PyObject *__pyx_n_s_Solution___setstate_cython; + PyObject *__pyx_n_s_Solution__checkStage; + PyObject *__pyx_n_s_Solution__evaluate; + PyObject *__pyx_n_s_StageNames; + PyObject *__pyx_n_s_StopIteration; + PyObject *__pyx_n_s_SumExpr; + PyObject *__pyx_n_s_SumExpr___reduce_cython; + PyObject *__pyx_n_s_SumExpr___setstate_cython; + PyObject *__pyx_n_s_TIMELIMIT; + PyObject *__pyx_n_s_TOTALNODELIMIT; + PyObject *__pyx_n_s_TRANSFORMED; + PyObject *__pyx_n_s_TRANSFORMING; + PyObject *__pyx_n_s_Term; + PyObject *__pyx_n_s_Term___add; + PyObject *__pyx_n_s_Term___eq; + PyObject *__pyx_n_s_Term___getitem; + PyObject *__pyx_n_s_Term___hash; + PyObject *__pyx_n_s_Term___init; + PyObject *__pyx_n_s_Term___init___locals_genexpr; + PyObject *__pyx_n_s_Term___init___locals_lambda; + PyObject *__pyx_n_s_Term___len; + PyObject *__pyx_n_s_Term___repr; + PyObject *__pyx_kp_u_Term_s; + PyObject *__pyx_kp_u_The_constraint_handler_s_does_no; + PyObject *__pyx_kp_u_The_given_capsule_does_not_conta; + PyObject *__pyx_kp_u_The_given_variable_is_not_a_pyva; + PyObject *__pyx_kp_u_The_problem_does_not_have_a_prim; + PyObject *__pyx_kp_s_This_is_a_monomial_term; + PyObject *__pyx_kp_u_To_create_a_solution_you_should; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s_UBCHANGED; + PyObject *__pyx_n_s_UBRELAXED; + PyObject *__pyx_n_s_UBTIGHTENED; + PyObject *__pyx_n_s_UNBOUNDED; + PyObject *__pyx_n_s_UNBOUNDEDRAY; + PyObject *__pyx_n_s_UNKNOWN; + PyObject *__pyx_n_s_UNSPEC; + PyObject *__pyx_n_s_UPWARDS; + PyObject *__pyx_n_s_USERINTERRUPT; + PyObject *__pyx_n_s_UnaryExpr; + PyObject *__pyx_n_s_UnaryExpr___reduce_cython; + PyObject *__pyx_n_s_UnaryExpr___setstate_cython; + PyObject *__pyx_n_s_Union; + PyObject *__pyx_kp_s_Union_Expr_GenExpr; + PyObject *__pyx_n_s_VARADDED; + PyObject *__pyx_n_s_VARCHANGED; + PyObject *__pyx_n_s_VARDELETED; + PyObject *__pyx_n_s_VAREVENT; + PyObject *__pyx_n_s_VARFIXED; + PyObject *__pyx_n_s_VARUNLOCKED; + PyObject *__pyx_n_s_ValueError; + PyObject *__pyx_n_s_VarExpr; + PyObject *__pyx_n_s_VarExpr___reduce_cython; + PyObject *__pyx_n_s_VarExpr___setstate_cython; + PyObject *__pyx_n_s_Variable; + PyObject *__pyx_n_s_Variable___reduce_cython; + PyObject *__pyx_n_s_Variable___setstate_cython; + PyObject *__pyx_n_s_Variable_getCol; + PyObject *__pyx_n_s_Variable_getIndex; + PyObject *__pyx_n_s_Variable_getLPSol; + PyObject *__pyx_n_s_Variable_getLbGlobal; + PyObject *__pyx_n_s_Variable_getLbLocal; + PyObject *__pyx_n_s_Variable_getLbOriginal; + PyObject *__pyx_n_s_Variable_getObj; + PyObject *__pyx_n_s_Variable_getUbGlobal; + PyObject *__pyx_n_s_Variable_getUbLocal; + PyObject *__pyx_n_s_Variable_getUbOriginal; + PyObject *__pyx_n_s_Variable_isInLP; + PyObject *__pyx_n_s_Variable_isOriginal; + PyObject *__pyx_n_s_Variable_ptr; + PyObject *__pyx_n_s_Variable_vtype; + PyObject *__pyx_n_s_Warning; + PyObject *__pyx_n_u_XORcons; + PyObject *__pyx_n_s_ZeroDivisionError; + PyObject *__pyx_kp_u__10; + PyObject *__pyx_kp_u__114; + PyObject *__pyx_n_s__1188; + PyObject *__pyx_n_s__126; + PyObject *__pyx_kp_u__126; + PyObject *__pyx_kp_u__162; + PyObject *__pyx_kp_u__163; + PyObject *__pyx_kp_u__164; + PyObject *__pyx_kp_u__165; + PyObject *__pyx_kp_u__2; + PyObject *__pyx_kp_u__441; + PyObject *__pyx_kp_u__442; + PyObject *__pyx_kp_u__6; + PyObject *__pyx_kp_u__79; + PyObject *__pyx_kp_u__89; + PyObject *__pyx_kp_u__9; + PyObject *__pyx_n_u__94; + PyObject *__pyx_n_u_abs; + PyObject *__pyx_n_s_absfile; + PyObject *__pyx_n_s_abspath; + PyObject *__pyx_n_s_activateBenders; + PyObject *__pyx_n_s_activeone; + PyObject *__pyx_n_s_activity; + PyObject *__pyx_n_s_add; + PyObject *__pyx_n_s_addBendersSubproblem; + PyObject *__pyx_n_s_addCoefLinear; + PyObject *__pyx_n_s_addCol; + PyObject *__pyx_n_s_addCols; + PyObject *__pyx_n_s_addCols_locals_genexpr; + PyObject *__pyx_n_s_addCons; + PyObject *__pyx_n_s_addConsAnd; + PyObject *__pyx_n_s_addConsCardinality; + PyObject *__pyx_n_s_addConsCoeff; + PyObject *__pyx_n_s_addConsDisjunction; + PyObject *__pyx_n_s_addConsDisjunction_locals_ensure; + PyObject *__pyx_n_s_addConsElemDisjunction; + PyObject *__pyx_n_s_addConsIndicator; + PyObject *__pyx_n_s_addConsLocal; + PyObject *__pyx_n_s_addConsNode; + PyObject *__pyx_n_s_addConsOr; + PyObject *__pyx_n_s_addConsSOS1; + PyObject *__pyx_n_s_addConsSOS2; + PyObject *__pyx_n_s_addConsXor; + PyObject *__pyx_n_s_addConss; + PyObject *__pyx_n_s_addConss_locals_ensure_iterable; + PyObject *__pyx_n_s_addCut; + PyObject *__pyx_n_s_addExprNonlinear; + PyObject *__pyx_kp_u_addExprNonlinear_can_only_be_cal; + PyObject *__pyx_kp_u_addExprNonlinear_cannot_be_calle; + PyObject *__pyx_n_s_addObjoffset; + PyObject *__pyx_n_s_addPoolCut; + PyObject *__pyx_n_s_addPyCons; + PyObject *__pyx_n_s_addRow; + PyObject *__pyx_n_s_addRowDive; + PyObject *__pyx_n_s_addRows; + PyObject *__pyx_n_s_addRows_locals_genexpr; + PyObject *__pyx_n_s_addSol; + PyObject *__pyx_n_s_addVar; + PyObject *__pyx_n_s_addVarLocks; + PyObject *__pyx_n_s_addVarSOS1; + PyObject *__pyx_n_s_addVarSOS2; + PyObject *__pyx_n_s_addVarToRow; + PyObject *__pyx_n_s_add_2; + PyObject *__pyx_n_s_addedconss; + PyObject *__pyx_n_s_addedconsssize; + PyObject *__pyx_n_s_allowaddcons; + PyObject *__pyx_n_s_allowlocal; + PyObject *__pyx_n_s_append; + PyObject *__pyx_n_s_appendVarSOS1; + PyObject *__pyx_n_s_appendVarSOS2; + PyObject *__pyx_n_s_applyCutsProbing; + PyObject *__pyx_n_s_args; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_attr; + PyObject *__pyx_n_s_auxvar; + PyObject *__pyx_n_s_auxvar_2; + PyObject *__pyx_n_u_auxviol; + PyObject *__pyx_n_s_backtrackProbing; + PyObject *__pyx_n_u_basic; + PyObject *__pyx_n_s_bdtype; + PyObject *__pyx_n_s_beg; + PyObject *__pyx_n_s_benders; + PyObject *__pyx_n_s_benders_2; + PyObject *__pyx_n_s_benderscreatesub; + PyObject *__pyx_n_s_benderscut; + PyObject *__pyx_n_s_benderscutexec; + PyObject *__pyx_n_s_benderscutexit; + PyObject *__pyx_n_s_benderscutexitsol; + PyObject *__pyx_n_s_benderscutfree; + PyObject *__pyx_n_s_benderscutinit; + PyObject *__pyx_n_s_benderscutinitsol; + PyObject *__pyx_n_s_bendersexit; + PyObject *__pyx_n_s_bendersexitpre; + PyObject *__pyx_n_s_bendersexitsol; + PyObject *__pyx_n_s_bendersfree; + PyObject *__pyx_n_s_bendersfreesub; + PyObject *__pyx_n_s_bendersgetvar; + PyObject *__pyx_n_s_bendersinit; + PyObject *__pyx_n_s_bendersinitpre; + PyObject *__pyx_n_s_bendersinitsol; + PyObject *__pyx_n_s_benderspostsolve; + PyObject *__pyx_n_s_benderspresubsolve; + PyObject *__pyx_n_s_benderssolvesub; + PyObject *__pyx_n_s_benderssolvesubconvex; + PyObject *__pyx_n_u_bestsollimit; + PyObject *__pyx_n_s_bilincoef; + PyObject *__pyx_n_s_bilinterm1; + PyObject *__pyx_n_s_bilinterm2; + PyObject *__pyx_n_s_bilinterms; + PyObject *__pyx_n_s_binVar; + PyObject *__pyx_n_s_binds; + PyObject *__pyx_n_s_binvar; + PyObject *__pyx_n_s_binvars; + PyObject *__pyx_n_s_both; + PyObject *__pyx_n_s_boundconstraint; + PyObject *__pyx_n_s_bounded; + PyObject *__pyx_n_s_boundtypes; + PyObject *__pyx_n_s_branchVar; + PyObject *__pyx_n_s_branchVarVal; + PyObject *__pyx_n_s_branchbounds; + PyObject *__pyx_n_s_branchdir; + PyObject *__pyx_n_s_branchexecext; + PyObject *__pyx_kp_u_branchexecext_is_a_fundamental_c; + PyObject *__pyx_n_s_branchexeclp; + PyObject *__pyx_kp_u_branchexeclp_is_a_fundamental_ca; + PyObject *__pyx_n_s_branchexecps; + PyObject *__pyx_kp_u_branchexecps_is_a_fundamental_ca; + PyObject *__pyx_n_s_branchexit; + PyObject *__pyx_n_s_branchexitsol; + PyObject *__pyx_n_s_branchfree; + PyObject *__pyx_n_s_branchinit; + PyObject *__pyx_n_s_branchinitsol; + PyObject *__pyx_n_s_branchrule; + PyObject *__pyx_n_s_branchvars; + PyObject *__pyx_n_s_buildGenExprObj; + PyObject *__pyx_n_s_c; + PyObject *__pyx_n_u_c; + PyObject *__pyx_n_s_c_beg; + PyObject *__pyx_n_s_c_binds; + PyObject *__pyx_n_s_c_coefs; + PyObject *__pyx_n_s_c_col; + PyObject *__pyx_n_s_c_dualsol; + PyObject *__pyx_n_s_c_inds; + PyObject *__pyx_n_s_c_lb; + PyObject *__pyx_n_s_c_lbs; + PyObject *__pyx_n_s_c_lhs; + PyObject *__pyx_n_s_c_lhss; + PyObject *__pyx_n_s_c_obj; + PyObject *__pyx_n_s_c_objs; + PyObject *__pyx_n_s_c_path; + PyObject *__pyx_n_s_c_primalsol; + PyObject *__pyx_n_s_c_ray; + PyObject *__pyx_n_s_c_redcost; + PyObject *__pyx_n_s_c_rhs; + PyObject *__pyx_n_s_c_rhss; + PyObject *__pyx_n_s_c_row; + PyObject *__pyx_n_s_c_ub; + PyObject *__pyx_n_s_c_ubs; + PyObject *__pyx_n_s_cacheRowExtensions; + PyObject *__pyx_n_s_calcChildEstimate; + PyObject *__pyx_n_s_calcNodeselPriority; + PyObject *__pyx_kp_u_can_only_be_called_with_a_valid; + PyObject *__pyx_kp_u_cannot_create_BoundChange_with_S; + PyObject *__pyx_kp_u_cannot_create_Column_with_SCIP_C; + PyObject *__pyx_kp_u_cannot_create_Constraint_with_SC; + PyObject *__pyx_kp_u_cannot_create_DomainChanges_with; + PyObject *__pyx_kp_u_cannot_create_Event_with_SCIP_EV; + PyObject *__pyx_kp_u_cannot_create_Model_with_SCIP_NU; + PyObject *__pyx_kp_u_cannot_create_NLRow_with_SCIP_NL; + PyObject *__pyx_kp_u_cannot_create_Row_with_SCIP_ROW; + PyObject *__pyx_kp_u_cannot_create_Solution_with_SCIP; + PyObject *__pyx_kp_u_cannot_create_Variable_with_SCIP; + PyObject *__pyx_kp_u_cannot_divide_by_0; + PyObject *__pyx_n_s_capsule; + PyObject *__pyx_n_s_cardval; + PyObject *__pyx_n_s_catchEvent; + PyObject *__pyx_n_s_catchRowEvent; + PyObject *__pyx_n_s_catchVarEvent; + PyObject *__pyx_n_s_category; + PyObject *__pyx_n_s_cfile; + PyObject *__pyx_n_s_chckpriority; + PyObject *__pyx_n_s_check; + PyObject *__pyx_n_u_check; + PyObject *__pyx_n_s_checkBendersSubproblemOptimality; + PyObject *__pyx_n_s_checkQuadraticNonlinear; + PyObject *__pyx_n_s_checkSol; + PyObject *__pyx_n_s_checkStage; + PyObject *__pyx_n_s_checkbounds; + PyObject *__pyx_n_s_checkint; + PyObject *__pyx_n_s_checkintegrality; + PyObject *__pyx_n_s_checklprows; + PyObject *__pyx_n_s_checktype; + PyObject *__pyx_n_s_chgBound; + PyObject *__pyx_n_s_chgCoef; + PyObject *__pyx_n_s_chgCoefLinear; + PyObject *__pyx_n_s_chgLhs; + PyObject *__pyx_n_s_chgObj; + PyObject *__pyx_n_s_chgReoptObjective; + PyObject *__pyx_n_s_chgRhs; + PyObject *__pyx_n_s_chgRowLhsDive; + PyObject *__pyx_n_s_chgRowRhsDive; + PyObject *__pyx_n_s_chgSide; + PyObject *__pyx_n_s_chgVarBranchPriority; + PyObject *__pyx_n_s_chgVarLb; + PyObject *__pyx_n_s_chgVarLbDive; + PyObject *__pyx_n_s_chgVarLbGlobal; + PyObject *__pyx_n_s_chgVarLbNode; + PyObject *__pyx_n_s_chgVarLbProbing; + PyObject *__pyx_n_s_chgVarObjDive; + PyObject *__pyx_n_s_chgVarObjProbing; + PyObject *__pyx_n_s_chgVarType; + PyObject *__pyx_n_s_chgVarUb; + PyObject *__pyx_n_s_chgVarUbDive; + PyObject *__pyx_n_s_chgVarUbGlobal; + PyObject *__pyx_n_s_chgVarUbNode; + PyObject *__pyx_n_s_chgVarUbProbing; + PyObject *__pyx_n_s_child; + PyObject *__pyx_n_s_children; + PyObject *__pyx_n_s_children_2; + PyObject *__pyx_n_s_childrenexpr; + PyObject *__pyx_n_s_chr; + PyObject *__pyx_kp_u_cip; + PyObject *__pyx_n_s_class; + PyObject *__pyx_n_s_class_getitem; + PyObject *__pyx_n_s_clear; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_close; + PyObject *__pyx_n_s_closefd; + PyObject *__pyx_n_s_cname; + PyObject *__pyx_n_s_coef; + PyObject *__pyx_n_s_coeff; + PyObject *__pyx_kp_u_coefficients_not_available_for_c; + PyObject *__pyx_n_s_coeffs; + PyObject *__pyx_n_s_coeffs_2; + PyObject *__pyx_n_s_coeffs_array; + PyObject *__pyx_n_s_coefs; + PyObject *__pyx_n_s_col; + PyObject *__pyx_n_s_collections_abc; + PyObject *__pyx_n_s_cols; + PyObject *__pyx_n_s_comments; + PyObject *__pyx_n_s_completely; + PyObject *__pyx_n_s_computeBestSolSubproblems; + PyObject *__pyx_n_s_confvar; + PyObject *__pyx_n_s_cons; + PyObject *__pyx_n_s_consactive; + PyObject *__pyx_n_s_conscheck; + PyObject *__pyx_n_s_conscopy; + PyObject *__pyx_n_s_consdeactive; + PyObject *__pyx_n_s_consdelete; + PyObject *__pyx_n_s_consdelvars; + PyObject *__pyx_n_s_consdisable; + PyObject *__pyx_n_s_consenable; + PyObject *__pyx_n_s_consenfolp; + PyObject *__pyx_n_s_consenfops; + PyObject *__pyx_n_s_consenforelax; + PyObject *__pyx_n_s_consexit; + PyObject *__pyx_n_s_consexitpre; + PyObject *__pyx_n_s_consexitsol; + PyObject *__pyx_n_s_consfree; + PyObject *__pyx_n_s_consgetdivebdchgs; + PyObject *__pyx_n_s_consgetnvars; + PyObject *__pyx_n_s_consgetpermsymgraph; + PyObject *__pyx_n_s_consgetsignedpermsymgraph; + PyObject *__pyx_n_s_consgetvars; + PyObject *__pyx_n_s_conshdlr; + PyObject *__pyx_n_s_conshdrlname; + PyObject *__pyx_n_s_consinit; + PyObject *__pyx_n_s_consinitlp; + PyObject *__pyx_n_s_consinitpre; + PyObject *__pyx_n_s_consinitsol; + PyObject *__pyx_n_s_conslock; + PyObject *__pyx_n_s_consparse; + PyObject *__pyx_n_s_conspresol; + PyObject *__pyx_n_s_consprint; + PyObject *__pyx_n_s_consprop; + PyObject *__pyx_n_s_consresprop; + PyObject *__pyx_n_s_conss; + PyObject *__pyx_n_s_conss_2; + PyObject *__pyx_n_s_conssepalp; + PyObject *__pyx_n_s_conssepasol; + PyObject *__pyx_n_s_const; + PyObject *__pyx_n_u_const; + PyObject *__pyx_n_s_constant; + PyObject *__pyx_n_s_constraint; + PyObject *__pyx_kp_u_constraint_is_not_nonlinear; + PyObject *__pyx_kp_u_constraint_is_not_quadratic; + PyObject *__pyx_n_s_constraints; + PyObject *__pyx_kp_u_constraints_benders_active; + PyObject *__pyx_kp_u_constraints_benderslp_active; + PyObject *__pyx_n_s_constrans; + PyObject *__pyx_n_s_constructLP; + PyObject *__pyx_n_s_constype; + PyObject *__pyx_n_s_consvars; + PyObject *__pyx_n_s_contvars; + PyObject *__pyx_n_s_copy; + PyObject *__pyx_n_s_cos; + PyObject *__pyx_n_u_cos; + PyObject *__pyx_kp_u_could_not_change_variable_type_o; + PyObject *__pyx_n_s_count; + PyObject *__pyx_n_s_createChild; + PyObject *__pyx_n_s_createCons; + PyObject *__pyx_n_s_createConsFromExpr; + PyObject *__pyx_n_s_createConsGenNonlinear; + PyObject *__pyx_n_s_createConsLinear; + PyObject *__pyx_n_s_createConsNonlinear; + PyObject *__pyx_n_s_createConsQuadratic; + PyObject *__pyx_n_s_createEmptyRowSepa; + PyObject *__pyx_n_s_createEmptyRowUnspec; + PyObject *__pyx_n_s_createOrigSol; + PyObject *__pyx_n_s_createPartialSol; + PyObject *__pyx_n_s_createProbBasic; + PyObject *__pyx_n_s_createSol; + PyObject *__pyx_n_s_createscip; + PyObject *__pyx_n_s_cut; + PyObject *__pyx_n_s_cutlp; + PyObject *__pyx_n_s_cutoff; + PyObject *__pyx_n_s_cutpseudo; + PyObject *__pyx_n_s_cutrelax; + PyObject *__pyx_n_s_cuts; + PyObject *__pyx_n_u_cuts; + PyObject *__pyx_n_s_cutsel; + PyObject *__pyx_n_s_cutselexit; + PyObject *__pyx_n_s_cutselexitsol; + PyObject *__pyx_n_s_cutselfree; + PyObject *__pyx_n_s_cutselinit; + PyObject *__pyx_n_s_cutselinitsol; + PyObject *__pyx_n_s_cutselselect; + PyObject *__pyx_n_s_d; + PyObject *__pyx_n_s_defaultPlugins; + PyObject *__pyx_n_s_deg; + PyObject *__pyx_n_s_degree; + PyObject *__pyx_n_s_degree_locals_genexpr; + PyObject *__pyx_n_s_delCoefLinear; + PyObject *__pyx_n_s_delCols; + PyObject *__pyx_n_s_delCons; + PyObject *__pyx_n_s_delConsLocal; + PyObject *__pyx_n_s_delRows; + PyObject *__pyx_n_s_delVar; + PyObject *__pyx_n_s_delay; + PyObject *__pyx_n_s_delayed; + PyObject *__pyx_n_s_delayprop; + PyObject *__pyx_n_s_delaysepa; + PyObject *__pyx_n_s_deleted; + PyObject *__pyx_n_s_des; + PyObject *__pyx_n_s_desc; + PyObject *__pyx_n_s_dict; + PyObject *__pyx_n_s_dict_2; + PyObject *__pyx_n_s_dis; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_n_s_disablePropagation; + PyObject *__pyx_n_s_disj_cons; + PyObject *__pyx_n_s_dispchar; + PyObject *__pyx_n_s_div; + PyObject *__pyx_n_s_doc; + PyObject *__pyx_n_s_domchg; + PyObject *__pyx_n_s_downchild; + PyObject *__pyx_n_s_dropEvent; + PyObject *__pyx_n_s_dropRowEvent; + PyObject *__pyx_n_s_dropVarEvent; + PyObject *__pyx_n_s_dual; + PyObject *__pyx_kp_u_dual_solution_values_not_availab; + PyObject *__pyx_n_u_duallimit; + PyObject *__pyx_n_s_dualsol; + PyObject *__pyx_n_s_dualsol_2; + PyObject *__pyx_n_s_dummy_boundtypes; + PyObject *__pyx_n_s_dummy_branchbounds; + PyObject *__pyx_n_s_dummy_branchvars; + PyObject *__pyx_n_s_dynamic; + PyObject *__pyx_n_u_dynamic; + PyObject *__pyx_n_s_e; + PyObject *__pyx_n_s_eagerfreq; + PyObject *__pyx_n_s_elem; + PyObject *__pyx_n_s_enable; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_enableReoptimization; + PyObject *__pyx_n_s_enablepricing; + PyObject *__pyx_n_s_endDive; + PyObject *__pyx_n_s_endProbing; + PyObject *__pyx_n_s_enfopriority; + PyObject *__pyx_n_s_enforce; + PyObject *__pyx_n_u_enforce; + PyObject *__pyx_n_s_enfotype; + PyObject *__pyx_n_s_ensure_iterable; + PyObject *__pyx_n_s_enter; + PyObject *__pyx_n_s_entries; + PyObject *__pyx_n_s_entrieslist; + PyObject *__pyx_n_s_entry; + PyObject *__pyx_n_s_enumerate; + PyObject *__pyx_n_s_epsilon; + PyObject *__pyx_n_s_eq; + PyObject *__pyx_n_s_eqchild; + PyObject *__pyx_n_s_error; + PyObject *__pyx_n_s_estimate; + PyObject *__pyx_n_s_evaluate; + PyObject *__pyx_n_s_event; + PyObject *__pyx_kp_u_event_handler_not_found; + PyObject *__pyx_n_s_eventcopy; + PyObject *__pyx_n_s_eventdelete; + PyObject *__pyx_n_s_eventexec; + PyObject *__pyx_n_s_eventexit; + PyObject *__pyx_n_s_eventexitsol; + PyObject *__pyx_n_s_eventfree; + PyObject *__pyx_n_s_eventhdlr; + PyObject *__pyx_n_s_eventhdlr_2; + PyObject *__pyx_n_s_eventinit; + PyObject *__pyx_n_s_eventinitsol; + PyObject *__pyx_n_s_eventtype; + PyObject *__pyx_n_s_exact; + PyObject *__pyx_n_s_exit; + PyObject *__pyx_n_s_exp; + PyObject *__pyx_n_u_exp; + PyObject *__pyx_kp_u_expected_inequality_that_has_eit; + PyObject *__pyx_kp_u_expected_linear_inequality_expre; + PyObject *__pyx_n_s_expo; + PyObject *__pyx_n_s_exponent; + PyObject *__pyx_kp_u_exponents_must_be_numbers; + PyObject *__pyx_n_s_expr; + PyObject *__pyx_n_s_expr_richcmp; + PyObject *__pyx_n_s_expr_to_array; + PyObject *__pyx_n_s_expr_to_nodes; + PyObject *__pyx_n_s_ext; + PyObject *__pyx_n_s_extend; + PyObject *__pyx_n_s_extension; + PyObject *__pyx_n_s_f; + PyObject *__pyx_n_s_fabs; + PyObject *__pyx_kp_u_failed; + PyObject *__pyx_n_s_fdopen; + PyObject *__pyx_n_s_feasFrac; + PyObject *__pyx_n_s_feasibility; + PyObject *__pyx_n_s_feasible; + PyObject *__pyx_n_s_feastol; + PyObject *__pyx_n_s_file; + PyObject *__pyx_n_s_filename; + PyObject *__pyx_n_s_fileno; + PyObject *__pyx_n_s_firstcol; + PyObject *__pyx_n_s_firstrow; + PyObject *__pyx_n_s_fixVar; + PyObject *__pyx_n_s_fixVarProbing; + PyObject *__pyx_n_s_fixed; + PyObject *__pyx_n_s_fixedval; + PyObject *__pyx_n_s_fixedvars; + PyObject *__pyx_n_s_flushRowExtensions; + PyObject *__pyx_n_s_fn; + PyObject *__pyx_n_s_force; + PyObject *__pyx_n_s_forcecut; + PyObject *__pyx_n_s_forcedcuts; + PyObject *__pyx_n_s_format; + PyObject *__pyx_n_s_frac; + PyObject *__pyx_n_s_free; + PyObject *__pyx_n_s_freeBendersSubproblems; + PyObject *__pyx_n_s_freeProb; + PyObject *__pyx_n_s_freeReoptSolve; + PyObject *__pyx_n_s_freeSol; + PyObject *__pyx_n_s_freeTransform; + PyObject *__pyx_n_s_freescip; + PyObject *__pyx_n_s_freq; + PyObject *__pyx_n_s_freqofs; + PyObject *__pyx_n_s_from_ptr; + PyObject *__pyx_n_u_gaplimit; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_genericnames; + PyObject *__pyx_n_s_genexpr; + PyObject *__pyx_n_s_get; + PyObject *__pyx_n_s_getActivity; + PyObject *__pyx_n_s_getAddedConss; + PyObject *__pyx_n_s_getBasisInds; + PyObject *__pyx_n_s_getBasisStatus; + PyObject *__pyx_n_s_getBendersAuxiliaryVar; + PyObject *__pyx_n_s_getBendersSubproblem; + PyObject *__pyx_n_s_getBendersVar; + PyObject *__pyx_n_s_getBestChild; + PyObject *__pyx_n_s_getBestLeaf; + PyObject *__pyx_n_s_getBestNode; + PyObject *__pyx_n_s_getBestSibling; + PyObject *__pyx_n_s_getBestSol; + PyObject *__pyx_n_s_getBestboundNode; + PyObject *__pyx_n_s_getBoundchgs; + PyObject *__pyx_n_s_getBoundchgtype; + PyObject *__pyx_n_s_getBounds; + PyObject *__pyx_n_s_getBoundtype; + PyObject *__pyx_n_s_getCol; + PyObject *__pyx_n_s_getCols; + PyObject *__pyx_n_s_getCondition; + PyObject *__pyx_n_s_getConsNVars; + PyObject *__pyx_n_s_getConsOriginConshdlrtype; + PyObject *__pyx_n_s_getConsVars; + PyObject *__pyx_n_s_getConshdlrName; + PyObject *__pyx_n_s_getConss; + PyObject *__pyx_n_s_getConstant; + PyObject *__pyx_n_s_getCurrentNode; + PyObject *__pyx_n_s_getCutEfficacy; + PyObject *__pyx_n_s_getCutLPSolCutoffDistance; + PyObject *__pyx_n_s_getDepth; + PyObject *__pyx_n_s_getDomchg; + PyObject *__pyx_n_s_getDual; + PyObject *__pyx_n_s_getDualMultiplier; + PyObject *__pyx_n_s_getDualRay; + PyObject *__pyx_n_s_getDualSolVal; + PyObject *__pyx_n_s_getDualbound; + PyObject *__pyx_n_s_getDualboundRoot; + PyObject *__pyx_n_s_getDualfarkasLinear; + PyObject *__pyx_n_s_getDualsol; + PyObject *__pyx_n_s_getDualsolLinear; + PyObject *__pyx_n_s_getEstimate; + PyObject *__pyx_n_s_getEventNames; + PyObject *__pyx_n_s_getGap; + PyObject *__pyx_n_s_getIndex; + PyObject *__pyx_n_s_getLPBInvARow; + PyObject *__pyx_n_s_getLPBInvRow; + PyObject *__pyx_n_s_getLPBasisInd; + PyObject *__pyx_n_s_getLPBranchCands; + PyObject *__pyx_n_s_getLPColsData; + PyObject *__pyx_n_s_getLPObjVal; + PyObject *__pyx_n_s_getLPPos; + PyObject *__pyx_n_s_getLPRowsData; + PyObject *__pyx_n_s_getLPSol; + PyObject *__pyx_n_s_getLPSolstat; + PyObject *__pyx_n_s_getLb; + PyObject *__pyx_n_s_getLbGlobal; + PyObject *__pyx_n_s_getLbLocal; + PyObject *__pyx_n_s_getLbOriginal; + PyObject *__pyx_n_s_getLhs; + PyObject *__pyx_n_s_getLinearTerms; + PyObject *__pyx_n_s_getLocalEstimate; + PyObject *__pyx_n_s_getLowerbound; + PyObject *__pyx_n_s_getNAddedConss; + PyObject *__pyx_n_s_getNBestSolsFound; + PyObject *__pyx_n_s_getNBinVars; + PyObject *__pyx_n_s_getNChildren; + PyObject *__pyx_n_s_getNConss; + PyObject *__pyx_n_s_getNCountedSols; + PyObject *__pyx_n_s_getNCuts; + PyObject *__pyx_n_s_getNCutsApplied; + PyObject *__pyx_n_s_getNDomchg; + PyObject *__pyx_n_s_getNFeasibleLeaves; + PyObject *__pyx_n_s_getNInfeasibleLeaves; + PyObject *__pyx_n_s_getNIntVars; + PyObject *__pyx_n_s_getNIterations; + PyObject *__pyx_n_s_getNLPCols; + PyObject *__pyx_n_s_getNLPIterations; + PyObject *__pyx_n_s_getNLPNonz; + PyObject *__pyx_n_s_getNLPRows; + PyObject *__pyx_n_s_getNLPs; + PyObject *__pyx_n_s_getNLeaves; + PyObject *__pyx_n_s_getNLimSolsFound; + PyObject *__pyx_n_s_getNNlRows; + PyObject *__pyx_n_s_getNNodes; + PyObject *__pyx_n_s_getNNonz; + PyObject *__pyx_n_s_getNParentBranchings; + PyObject *__pyx_n_s_getNReaders; + PyObject *__pyx_n_s_getNSepaRounds; + PyObject *__pyx_n_s_getNSiblings; + PyObject *__pyx_n_s_getNSols; + PyObject *__pyx_n_s_getNSolsFound; + PyObject *__pyx_n_s_getNTotalNodes; + PyObject *__pyx_n_s_getNVars; + PyObject *__pyx_n_s_getName; + PyObject *__pyx_n_s_getNewBound; + PyObject *__pyx_n_s_getNlRowActivityBounds; + PyObject *__pyx_n_s_getNlRowSolActivity; + PyObject *__pyx_n_s_getNlRowSolFeasibility; + PyObject *__pyx_n_s_getNlRows; + PyObject *__pyx_n_s_getNode; + PyObject *__pyx_n_s_getNorm; + PyObject *__pyx_n_s_getNumber; + PyObject *__pyx_n_s_getObj; + PyObject *__pyx_n_s_getObjCoeff; + PyObject *__pyx_n_s_getObjVal; + PyObject *__pyx_n_s_getObjective; + PyObject *__pyx_n_s_getObjectiveSense; + PyObject *__pyx_n_s_getObjlimit; + PyObject *__pyx_n_s_getObjoffset; + PyObject *__pyx_n_s_getOldBound; + PyObject *__pyx_n_s_getOp; + PyObject *__pyx_n_s_getOpenNodes; + PyObject *__pyx_n_s_getOrigintype; + PyObject *__pyx_n_s_getParam; + PyObject *__pyx_n_s_getParams; + PyObject *__pyx_n_s_getParent; + PyObject *__pyx_n_s_getParentBranchings; + PyObject *__pyx_n_s_getPresolvingTime; + PyObject *__pyx_n_s_getPrimal; + PyObject *__pyx_n_s_getPrimalRay; + PyObject *__pyx_n_s_getPrimalRayVal; + PyObject *__pyx_n_s_getPrimalbound; + PyObject *__pyx_n_s_getPrimsol; + PyObject *__pyx_n_s_getProbName; + PyObject *__pyx_n_s_getProbingDepth; + PyObject *__pyx_n_s_getPseudoBranchCands; + PyObject *__pyx_n_s_getReadingTime; + PyObject *__pyx_n_s_getRedcost; + PyObject *__pyx_n_s_getRhs; + PyObject *__pyx_n_s_getRow; + PyObject *__pyx_n_s_getRowActivity; + PyObject *__pyx_n_s_getRowDualSol; + PyObject *__pyx_n_s_getRowLPActivity; + PyObject *__pyx_n_s_getRowLinear; + PyObject *__pyx_n_s_getRowNumIntCols; + PyObject *__pyx_n_s_getRowObjParallelism; + PyObject *__pyx_n_s_getRowParallelism; + PyObject *__pyx_n_s_getSides; + PyObject *__pyx_n_s_getSlack; + PyObject *__pyx_n_s_getSlackVarIndicator; + PyObject *__pyx_n_s_getSolObjVal; + PyObject *__pyx_n_u_getSolObjVal; + PyObject *__pyx_n_s_getSolTime; + PyObject *__pyx_n_s_getSolVal; + PyObject *__pyx_n_s_getSols; + PyObject *__pyx_n_s_getSolvingTime; + PyObject *__pyx_n_s_getStage; + PyObject *__pyx_n_s_getStageName; + PyObject *__pyx_n_s_getStageNames; + PyObject *__pyx_n_s_getStatus; + PyObject *__pyx_n_s_getTermsQuadratic; + PyObject *__pyx_n_s_getTotalTime; + PyObject *__pyx_n_s_getTransformedCons; + PyObject *__pyx_n_s_getTransformedVar; + PyObject *__pyx_n_s_getTreesizeEstimation; + PyObject *__pyx_n_s_getType; + PyObject *__pyx_n_s_getUb; + PyObject *__pyx_n_s_getUbGlobal; + PyObject *__pyx_n_s_getUbLocal; + PyObject *__pyx_n_s_getUbOriginal; + PyObject *__pyx_n_s_getVal; + PyObject *__pyx_n_s_getVals; + PyObject *__pyx_n_s_getValsLinear; + PyObject *__pyx_n_s_getVar; + PyObject *__pyx_n_s_getVarDict; + PyObject *__pyx_n_s_getVarLbDive; + PyObject *__pyx_n_s_getVarRedcost; + PyObject *__pyx_n_s_getVarUbDive; + PyObject *__pyx_n_s_getVars; + PyObject *__pyx_n_s_getitem; + PyObject *__pyx_n_s_getitem___locals_genexpr; + PyObject *__pyx_n_s_getlocale; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_give_ownership; + PyObject *__pyx_kp_u_given_coefficients_are_neither_E; + PyObject *__pyx_kp_u_given_coefficients_are_not_Expr; + PyObject *__pyx_kp_u_given_constraint_is_not_ExprCons; + PyObject *__pyx_kp_u_given_constraint_is_not_linear_d; + PyObject *__pyx_kp_u_given_constraint_is_not_quadrati; + PyObject *__pyx_n_s_globalcopy; + PyObject *__pyx_n_s_hasPrimalRay; + PyObject *__pyx_n_s_hash; + PyObject *__pyx_n_s_hashval; + PyObject *__pyx_n_u_hashval; + PyObject *__pyx_n_s_heur; + PyObject *__pyx_n_s_heur_2; + PyObject *__pyx_n_s_heurexec; + PyObject *__pyx_n_s_heurexit; + PyObject *__pyx_n_s_heurexitsol; + PyObject *__pyx_n_s_heurfree; + PyObject *__pyx_n_s_heurinit; + PyObject *__pyx_n_s_heurinitsol; + PyObject *__pyx_n_s_heurtiming; + PyObject *__pyx_n_s_hideOutput; + PyObject *__pyx_n_s_i; + PyObject *__pyx_n_s_idx; + PyObject *__pyx_n_s_idxs; + PyObject *__pyx_n_s_implvars; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_inProbing; + PyObject *__pyx_n_s_inRepropagation; + PyObject *__pyx_n_s_includeBenders; + PyObject *__pyx_n_s_includeBendersDefaultCuts; + PyObject *__pyx_n_s_includeBenderscut; + PyObject *__pyx_n_s_includeBranchrule; + PyObject *__pyx_n_s_includeConshdlr; + PyObject *__pyx_n_s_includeCutsel; + PyObject *__pyx_n_s_includeDefaultPlugins; + PyObject *__pyx_n_s_includeEventhdlr; + PyObject *__pyx_n_s_includeHeur; + PyObject *__pyx_n_s_includeNodesel; + PyObject *__pyx_n_s_includePresol; + PyObject *__pyx_n_s_includePricer; + PyObject *__pyx_n_s_includeProp; + PyObject *__pyx_n_s_includeReader; + PyObject *__pyx_n_s_includeRelax; + PyObject *__pyx_n_s_includeSepa; + PyObject *__pyx_n_s_indices; + PyObject *__pyx_n_s_inds; + PyObject *__pyx_n_s_indvar; + PyObject *__pyx_n_s_indvars; + PyObject *__pyx_n_u_inf; + PyObject *__pyx_n_s_infeasible; + PyObject *__pyx_n_u_infeasible; + PyObject *__pyx_n_s_infeasible_2; + PyObject *__pyx_n_s_inferinfo; + PyObject *__pyx_n_s_infinity; + PyObject *__pyx_n_u_inforunbd; + PyObject *__pyx_n_s_init; + PyObject *__pyx_n_s_initBendersDefault; + PyObject *__pyx_n_s_init_subclass; + PyObject *__pyx_n_s_initial; + PyObject *__pyx_n_u_initial; + PyObject *__pyx_n_s_initializing; + PyObject *__pyx_n_s_interruptSolve; + PyObject *__pyx_n_s_intvars; + PyObject *__pyx_n_s_isActive; + PyObject *__pyx_n_s_isChecked; + PyObject *__pyx_n_s_isCutEfficacious; + PyObject *__pyx_n_s_isDualFeasible; + PyObject *__pyx_n_s_isDynamic; + PyObject *__pyx_n_s_isEQ; + PyObject *__pyx_n_s_isEnforced; + PyObject *__pyx_n_s_isFeasEQ; + PyObject *__pyx_n_s_isFeasIntegral; + PyObject *__pyx_n_s_isFeasNegative; + PyObject *__pyx_n_s_isFeasZero; + PyObject *__pyx_n_s_isGE; + PyObject *__pyx_n_s_isGT; + PyObject *__pyx_n_s_isInGlobalCutpool; + PyObject *__pyx_n_s_isInLP; + PyObject *__pyx_n_s_isInfinity; + PyObject *__pyx_n_s_isInitial; + PyObject *__pyx_n_s_isIntegral; + PyObject *__pyx_n_s_isLE; + PyObject *__pyx_n_s_isLPSolBasic; + PyObject *__pyx_n_s_isLT; + PyObject *__pyx_n_s_isLinear; + PyObject *__pyx_n_s_isLocal; + PyObject *__pyx_n_s_isModifiable; + PyObject *__pyx_n_s_isNLPConstructed; + PyObject *__pyx_n_s_isNonlinear; + PyObject *__pyx_n_s_isObjChangedProbing; + PyObject *__pyx_n_s_isOriginal; + PyObject *__pyx_n_s_isPrimalFeasible; + PyObject *__pyx_n_s_isPropagated; + PyObject *__pyx_n_s_isPropagatedAgain; + PyObject *__pyx_n_s_isRedundant; + PyObject *__pyx_n_s_isRemovable; + PyObject *__pyx_n_s_isSeparated; + PyObject *__pyx_n_s_isStickingAtNode; + PyObject *__pyx_n_s_isZero; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_n_s_is_integer; + PyObject *__pyx_n_s_is_memory_freed; + PyObject *__pyx_n_s_is_number; + PyObject *__pyx_n_s_isconvex; + PyObject *__pyx_n_s_isdict; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_islpcut; + PyObject *__pyx_n_s_isquadratic; + PyObject *__pyx_n_s_items; + PyObject *__pyx_n_s_iters; + PyObject *__pyx_n_s_itertools; + PyObject *__pyx_n_s_itlim; + PyObject *__pyx_n_s_j; + PyObject *__pyx_n_s_key; + PyObject *__pyx_n_s_keys; + PyObject *__pyx_n_s_kwargs; + PyObject *__pyx_n_s_lambda; + PyObject *__pyx_n_s_lastcol; + PyObject *__pyx_n_s_lastrow; + PyObject *__pyx_n_s_lb; + PyObject *__pyx_n_s_lbs; + PyObject *__pyx_n_s_leaves; + PyObject *__pyx_n_s_leaves_2; + PyObject *__pyx_n_s_len; + PyObject *__pyx_n_s_length; + PyObject *__pyx_n_s_lhs; + PyObject *__pyx_n_u_lhs; + PyObject *__pyx_n_s_lhs_2; + PyObject *__pyx_n_s_lhss; + PyObject *__pyx_n_s_lhsslack; + PyObject *__pyx_n_s_lincoef; + PyObject *__pyx_n_s_lincoefs; + PyObject *__pyx_n_s_lincoefs_2; + PyObject *__pyx_n_s_lincons; + PyObject *__pyx_n_u_linear; + PyObject *__pyx_n_s_linexprs; + PyObject *__pyx_kp_u_linked_SCIP_is_not_compatible_to; + PyObject *__pyx_kp_u_linked_SCIP_is_not_recommended_f; + PyObject *__pyx_n_s_linterms; + PyObject *__pyx_n_s_linvars; + PyObject *__pyx_n_s_local; + PyObject *__pyx_n_u_local; + PyObject *__pyx_n_s_locale; + PyObject *__pyx_n_s_locktype; + PyObject *__pyx_n_s_log; + PyObject *__pyx_n_u_log; + PyObject *__pyx_n_u_lower; + PyObject *__pyx_n_u_lowerbound; + PyObject *__pyx_n_s_lowerbounds; + PyObject *__pyx_n_s_lpcands; + PyObject *__pyx_n_s_lpcandsfrac; + PyObject *__pyx_n_s_lpcandssol; + PyObject *__pyx_n_s_lperror; + PyObject *__pyx_n_s_lpi; + PyObject *__pyx_n_s_lpiGetIterations; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_map; + PyObject *__pyx_n_s_mappedvar; + PyObject *__pyx_n_u_mappedvar; + PyObject *__pyx_n_s_mappedvar_2; + PyObject *__pyx_n_s_max; + PyObject *__pyx_n_s_maxactivity; + PyObject *__pyx_n_s_maxbounddist; + PyObject *__pyx_n_s_maxdepth; + PyObject *__pyx_n_u_maximize; + PyObject *__pyx_n_s_maxnconss; + PyObject *__pyx_n_s_maxnselectedcuts; + PyObject *__pyx_n_s_maxprerounds; + PyObject *__pyx_n_s_maxproprounds; + PyObject *__pyx_n_s_maxrounds; + PyObject *__pyx_n_u_memlimit; + PyObject *__pyx_n_s_memsavepriority; + PyObject *__pyx_n_s_mergecandidates; + PyObject *__pyx_n_u_merged; + PyObject *__pyx_n_s_metaclass; + PyObject *__pyx_n_s_method; + PyObject *__pyx_kp_u_method_can_only_be_called_in_sta; + PyObject *__pyx_kp_u_method_cannot_be_called_before_p; + PyObject *__pyx_kp_u_method_cannot_be_called_for_cons; + PyObject *__pyx_n_s_minactivity; + PyObject *__pyx_n_u_minimize; + PyObject *__pyx_n_s_minus; + PyObject *__pyx_n_s_model; + PyObject *__pyx_n_u_model; + PyObject *__pyx_kp_u_model_cip; + PyObject *__pyx_kp_u_model_getDualMultiplier_cons_is; + PyObject *__pyx_n_s_modifiable; + PyObject *__pyx_n_u_modifiable; + PyObject *__pyx_n_s_module; + PyObject *__pyx_n_s_monomials; + PyObject *__pyx_n_s_mul; + PyObject *__pyx_n_s_mul_2; + PyObject *__pyx_n_s_myMessageHandler; + PyObject *__pyx_n_s_n; + PyObject *__pyx_n_s_n_conss; + PyObject *__pyx_n_u_naddconss; + PyObject *__pyx_n_u_naddholes; + PyObject *__pyx_n_u_naggrvars; + PyObject *__pyx_n_s_nam; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_u_name; + PyObject *__pyx_n_s_name_2; + PyObject *__pyx_n_s_nbenders; + PyObject *__pyx_n_s_nbilinterms; + PyObject *__pyx_n_s_nboundchgs; + PyObject *__pyx_n_s_nbranchings; + PyObject *__pyx_n_s_nbranchvars; + PyObject *__pyx_n_s_ncands; + PyObject *__pyx_n_u_nchgbds; + PyObject *__pyx_n_u_nchgcoefs; + PyObject *__pyx_n_u_nchgsides; + PyObject *__pyx_n_u_nchgvartypes; + PyObject *__pyx_n_s_nchildren; + PyObject *__pyx_n_s_nchildren_2; + PyObject *__pyx_n_s_ncols; + PyObject *__pyx_n_s_nconsprop; + PyObject *__pyx_n_s_nconss; + PyObject *__pyx_n_s_nconss_2; + PyObject *__pyx_n_u_ndelconss; + PyObject *__pyx_n_s_ndomredsfound; + PyObject *__pyx_n_s_needscons; + PyObject *__pyx_n_s_negate; + PyObject *__pyx_n_s_new; + PyObject *__pyx_n_s_newCheck; + PyObject *__pyx_n_s_newEnf; + PyObject *__pyx_n_s_newInit; + PyObject *__pyx_n_s_newProbingNode; + PyObject *__pyx_n_s_newRem; + PyObject *__pyx_n_s_newbound; + PyObject *__pyx_n_s_newlhs; + PyObject *__pyx_n_s_newobj; + PyObject *__pyx_n_s_newrhs; + PyObject *__pyx_n_s_newval; + PyObject *__pyx_n_u_nfixedvars; + PyObject *__pyx_n_s_nfracimplvars; + PyObject *__pyx_n_s_niters; + PyObject *__pyx_n_s_nleaves; + PyObject *__pyx_n_s_nlinvars; + PyObject *__pyx_n_s_nlinvars_2; + PyObject *__pyx_n_s_nlocksdown; + PyObject *__pyx_n_s_nlocksneg; + PyObject *__pyx_n_s_nlockspos; + PyObject *__pyx_n_s_nlocksup; + PyObject *__pyx_n_s_nlpcands; + PyObject *__pyx_n_s_nlrow; + PyObject *__pyx_n_s_nlrows; + PyObject *__pyx_n_s_nmarkedconss; + PyObject *__pyx_n_s_nnewaddconss; + PyObject *__pyx_n_u_nnewaddconss; + PyObject *__pyx_n_u_nnewaddholes; + PyObject *__pyx_n_s_nnewaggrvars; + PyObject *__pyx_n_u_nnewaggrvars; + PyObject *__pyx_n_s_nnewchgbds; + PyObject *__pyx_n_u_nnewchgbds; + PyObject *__pyx_n_s_nnewchgcoefs; + PyObject *__pyx_n_u_nnewchgcoefs; + PyObject *__pyx_n_s_nnewchgsides; + PyObject *__pyx_n_u_nnewchgsides; + PyObject *__pyx_n_s_nnewchgvartypes; + PyObject *__pyx_n_u_nnewchgvartypes; + PyObject *__pyx_n_s_nnewdelconss; + PyObject *__pyx_n_u_nnewdelconss; + PyObject *__pyx_n_s_nnewfixedvars; + PyObject *__pyx_n_u_nnewfixedvars; + PyObject *__pyx_n_s_nnewholes; + PyObject *__pyx_n_s_nnewupgdconss; + PyObject *__pyx_n_u_nnewupgdconss; + PyObject *__pyx_n_s_nnonz; + PyObject *__pyx_kp_u_no_reduced_cost_available_for_va; + PyObject *__pyx_n_s_node; + PyObject *__pyx_n_s_node1; + PyObject *__pyx_n_s_node2; + PyObject *__pyx_n_s_nodecomp; + PyObject *__pyx_n_s_nodeexit; + PyObject *__pyx_n_s_nodeexitsol; + PyObject *__pyx_n_s_nodefree; + PyObject *__pyx_n_s_nodeinfeasible; + PyObject *__pyx_n_s_nodeinit; + PyObject *__pyx_n_s_nodeinitsol; + PyObject *__pyx_n_u_nodelimit; + PyObject *__pyx_n_s_nodes; + PyObject *__pyx_n_s_nodesel; + PyObject *__pyx_n_s_nodeselect; + PyObject *__pyx_n_s_nodeselprio; + PyObject *__pyx_n_u_nonlinear; + PyObject *__pyx_n_s_normalize; + PyObject *__pyx_n_s_npriolpcands; + PyObject *__pyx_n_s_npriomergecands; + PyObject *__pyx_n_s_npriopseudocands; + PyObject *__pyx_n_s_nprop; + PyObject *__pyx_n_s_npseudocands; + PyObject *__pyx_n_s_nquadterms; + PyObject *__pyx_n_s_nrounds; + PyObject *__pyx_n_s_nrows; + PyObject *__pyx_n_u_nselectedcuts; + PyObject *__pyx_n_s_nsiblings; + PyObject *__pyx_n_s_nsols; + PyObject *__pyx_n_s_nsubproblems; + PyObject *__pyx_n_s_number; + PyObject *__pyx_n_u_nupgdconss; + PyObject *__pyx_n_s_nusefulconss; + PyObject *__pyx_n_s_nvars; + PyObject *__pyx_n_u_nvars; + PyObject *__pyx_n_s_nvars_2; + PyObject *__pyx_n_s_obj; + PyObject *__pyx_n_s_objective; + PyObject *__pyx_n_u_objective; + PyObject *__pyx_n_s_objinfeasible; + PyObject *__pyx_n_s_objlimit; + PyObject *__pyx_n_s_objoffset; + PyObject *__pyx_n_s_objs; + PyObject *__pyx_n_s_objscale; + PyObject *__pyx_n_s_objsense; + PyObject *__pyx_n_s_objval; + PyObject *__pyx_n_s_offset; + PyObject *__pyx_n_s_onlychanged; + PyObject *__pyx_n_s_onlyconvex; + PyObject *__pyx_n_s_onlydelayed; + PyObject *__pyx_n_s_onlyroot; + PyObject *__pyx_n_s_op; + PyObject *__pyx_n_s_op_2; + PyObject *__pyx_n_s_open; + PyObject *__pyx_n_s_opidx; + PyObject *__pyx_n_s_optimal; + PyObject *__pyx_n_u_optimal; + PyObject *__pyx_n_s_optimize; + PyObject *__pyx_n_s_origcopy; + PyObject *__pyx_n_s_original; + PyObject *__pyx_kp_u_origprob_sol; + PyObject *__pyx_kp_u_origprob_stats; + PyObject *__pyx_n_s_orthofunc; + PyObject *__pyx_n_s_os; + PyObject *__pyx_n_s_os_path; + PyObject *__pyx_n_s_other; + PyObject *__pyx_n_s_paraemphasis; + PyObject *__pyx_n_s_param; + PyObject *__pyx_kp_u_param_set; + PyObject *__pyx_n_s_params; + PyObject *__pyx_n_s_paramtype; + PyObject *__pyx_n_s_partial; + PyObject *__pyx_n_s_partialsolution; + PyObject *__pyx_n_s_path; + PyObject *__pyx_n_s_pickle; + PyObject *__pyx_n_s_plus; + PyObject *__pyx_n_s_pos; + PyObject *__pyx_n_s_power; + PyObject *__pyx_n_s_prepare; + PyObject *__pyx_n_s_presol; + PyObject *__pyx_n_s_presolexec; + PyObject *__pyx_n_s_presolexit; + PyObject *__pyx_n_s_presolexitpre; + PyObject *__pyx_n_s_presolfree; + PyObject *__pyx_n_s_presolinit; + PyObject *__pyx_n_s_presolinitpre; + PyObject *__pyx_n_s_presolmaxrounds; + PyObject *__pyx_n_s_presolpriority; + PyObject *__pyx_n_s_presoltiming; + PyObject *__pyx_n_s_presolve; + PyObject *__pyx_n_s_pretendroot; + PyObject *__pyx_n_s_pricedVar; + PyObject *__pyx_n_s_pricedVarScore; + PyObject *__pyx_n_s_pricer; + PyObject *__pyx_n_s_pricerexit; + PyObject *__pyx_n_s_pricerexitsol; + PyObject *__pyx_n_s_pricerfarkas; + PyObject *__pyx_kp_u_pricerfarkas_is_a_fundamental_ca; + PyObject *__pyx_n_s_pricerfree; + PyObject *__pyx_n_s_pricerinit; + PyObject *__pyx_n_s_pricerinitsol; + PyObject *__pyx_n_s_pricerredcost; + PyObject *__pyx_kp_u_pricerredcost_is_a_fundamental_c; + PyObject *__pyx_n_u_primallimit; + PyObject *__pyx_n_s_primalsol; + PyObject *__pyx_n_s_print; + PyObject *__pyx_n_s_printBestSol; + PyObject *__pyx_n_s_printCons; + PyObject *__pyx_n_s_printExternalCodeVersions; + PyObject *__pyx_n_s_printNlRow; + PyObject *__pyx_n_s_printRow; + PyObject *__pyx_n_s_printSol; + PyObject *__pyx_n_s_printStatistics; + PyObject *__pyx_n_s_printVersion; + PyObject *__pyx_n_s_print_memory_in_use; + PyObject *__pyx_n_s_printreason; + PyObject *__pyx_n_s_priority; + PyObject *__pyx_n_s_probingdepth; + PyObject *__pyx_n_s_problemName; + PyObject *__pyx_n_s_probnumber; + PyObject *__pyx_n_s_prod; + PyObject *__pyx_n_u_prod; + PyObject *__pyx_n_s_prodexpr; + PyObject *__pyx_n_s_prop; + PyObject *__pyx_n_s_propagate; + PyObject *__pyx_n_u_propagate; + PyObject *__pyx_n_s_propagateProbing; + PyObject *__pyx_kp_u_propagating_maxrounds; + PyObject *__pyx_kp_u_propagating_maxroundsroot; + PyObject *__pyx_n_s_propexec; + PyObject *__pyx_n_s_propexit; + PyObject *__pyx_n_s_propexitpre; + PyObject *__pyx_n_s_propexitsol; + PyObject *__pyx_n_s_propfree; + PyObject *__pyx_n_s_propfreq; + PyObject *__pyx_n_s_propinit; + PyObject *__pyx_n_s_propinitpre; + PyObject *__pyx_n_s_propinitsol; + PyObject *__pyx_n_s_proppresol; + PyObject *__pyx_n_s_propresprop; + PyObject *__pyx_n_s_proptiming; + PyObject *__pyx_n_s_proxy; + PyObject *__pyx_n_s_pseudocands; + PyObject *__pyx_n_s_ptr; + PyObject *__pyx_n_s_ptrtuple; + PyObject *__pyx_n_u_ptrtuple; + PyObject *__pyx_n_s_pyCons; + PyObject *__pyx_n_s_pyVar; + PyObject *__pyx_n_s_py_boundtypes; + PyObject *__pyx_n_s_py_branchbounds; + PyObject *__pyx_n_s_py_variables; + PyObject *__pyx_n_s_pycons; + PyObject *__pyx_n_s_pycons_initial; + PyObject *__pyx_n_s_pyscipopt_scip; + PyObject *__pyx_kp_u_python_error_in_benderscreatesub; + PyObject *__pyx_kp_u_python_error_in_benderscutexec_t; + PyObject *__pyx_kp_u_python_error_in_bendersgetvar_th; + PyObject *__pyx_kp_u_python_error_in_conscheck_this_m; + PyObject *__pyx_kp_u_python_error_in_consenfolp_this; + PyObject *__pyx_kp_u_python_error_in_consenfops_this; + PyObject *__pyx_kp_u_python_error_in_consenforelax_th; + PyObject *__pyx_kp_u_python_error_in_conslock_this_me; + PyObject *__pyx_kp_u_python_error_in_eventexec_this_m; + PyObject *__pyx_kp_u_python_error_in_heurexec_this_me; + PyObject *__pyx_kp_u_python_error_in_presolexec_this; + PyObject *__pyx_kp_u_python_error_in_propexec_this_me; + PyObject *__pyx_kp_u_python_error_in_propresprop_this; + PyObject *__pyx_kp_u_python_error_in_relaxexec_this_m; + PyObject *__pyx_n_s_pyvar; + PyObject *__pyx_n_s_pyx_PickleError; + PyObject *__pyx_n_s_pyx_checksum; + PyObject *__pyx_n_s_pyx_result; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_type; + PyObject *__pyx_n_s_pyx_unpickle_Benderscut; + PyObject *__pyx_n_s_pyx_unpickle_Branchrule; + PyObject *__pyx_n_s_pyx_unpickle_Conshdlr; + PyObject *__pyx_n_s_pyx_unpickle_Constant; + PyObject *__pyx_n_s_pyx_unpickle_Cutsel; + PyObject *__pyx_n_s_pyx_unpickle_Eventhdlr; + PyObject *__pyx_n_s_pyx_unpickle_Expr; + PyObject *__pyx_n_s_pyx_unpickle_ExprCons; + PyObject *__pyx_n_s_pyx_unpickle_GenExpr; + PyObject *__pyx_n_s_pyx_unpickle_Heur; + PyObject *__pyx_n_s_pyx_unpickle_Nodesel; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_RESULT; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_STAGE; + PyObject *__pyx_n_s_pyx_unpickle_PY_SCIP_STATUS; + PyObject *__pyx_n_s_pyx_unpickle_PowExpr; + PyObject *__pyx_n_s_pyx_unpickle_Presol; + PyObject *__pyx_n_s_pyx_unpickle_Pricer; + PyObject *__pyx_n_s_pyx_unpickle_ProdExpr; + PyObject *__pyx_n_s_pyx_unpickle_Prop; + PyObject *__pyx_n_s_pyx_unpickle_Reader; + PyObject *__pyx_n_s_pyx_unpickle_Relax; + PyObject *__pyx_n_s_pyx_unpickle_Sepa; + PyObject *__pyx_n_s_pyx_unpickle_SumExpr; + PyObject *__pyx_n_s_pyx_unpickle_UnaryExpr; + PyObject *__pyx_n_s_pyx_unpickle_VarExpr; + PyObject *__pyx_n_s_pyx_vtable; + PyObject *__pyx_n_s_quadcons; + PyObject *__pyx_n_u_quadratic; + PyObject *__pyx_n_s_quadterms; + PyObject *__pyx_n_s_quality; + PyObject *__pyx_n_s_qualname; + PyObject *__pyx_n_s_quickprod; + PyObject *__pyx_n_s_quicksum; + PyObject *__pyx_n_s_quiet; + PyObject *__pyx_n_s_raise_error; + PyObject *__pyx_n_s_range; + PyObject *__pyx_n_s_ray; + PyObject *__pyx_n_s_rc; + PyObject *__pyx_n_s_readLP; + PyObject *__pyx_n_s_readParams; + PyObject *__pyx_n_s_readProblem; + PyObject *__pyx_n_s_readSol; + PyObject *__pyx_n_s_readSolFile; + PyObject *__pyx_n_s_reader; + PyObject *__pyx_n_s_readerfree; + PyObject *__pyx_n_s_readerread; + PyObject *__pyx_n_s_readerwrite; + PyObject *__pyx_n_s_redcost; + PyObject *__pyx_n_s_redirectOutput; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_relax; + PyObject *__pyx_n_s_relaxcons; + PyObject *__pyx_n_s_relaxedbd; + PyObject *__pyx_n_s_relaxexec; + PyObject *__pyx_kp_u_relaxexec_must_return_a_dictiona; + PyObject *__pyx_n_s_relaxexit; + PyObject *__pyx_n_s_relaxexitsol; + PyObject *__pyx_n_s_relaxfree; + PyObject *__pyx_n_s_relaxinit; + PyObject *__pyx_n_s_relaxinitsol; + PyObject *__pyx_n_s_releaseRow; + PyObject *__pyx_n_s_removable; + PyObject *__pyx_n_u_removable; + PyObject *__pyx_n_s_repeat; + PyObject *__pyx_n_s_repr; + PyObject *__pyx_n_s_repr___locals_lambda; + PyObject *__pyx_n_s_repropagateNode; + PyObject *__pyx_n_s_resVar; + PyObject *__pyx_n_s_resetParam; + PyObject *__pyx_n_s_resetParams; + PyObject *__pyx_n_s_restart; + PyObject *__pyx_n_s_restartSolve; + PyObject *__pyx_n_u_restartlimit; + PyObject *__pyx_n_s_result; + PyObject *__pyx_n_u_result; + PyObject *__pyx_n_s_result_dict; + PyObject *__pyx_n_s_resvar; + PyObject *__pyx_n_s_retcode; + PyObject *__pyx_n_s_rhs; + PyObject *__pyx_n_u_rhs; + PyObject *__pyx_n_s_rhs_2; + PyObject *__pyx_n_s_rhss; + PyObject *__pyx_n_s_rhsslack; + PyObject *__pyx_n_s_rhsvar; + PyObject *__pyx_n_s_root; + PyObject *__pyx_n_s_row; + PyObject *__pyx_n_u_row; + PyObject *__pyx_n_s_row1; + PyObject *__pyx_n_s_row2; + PyObject *__pyx_n_s_rows; + PyObject *__pyx_n_s_scip_benders; + PyObject *__pyx_n_s_scip_benderscut; + PyObject *__pyx_n_s_scip_col; + PyObject *__pyx_n_s_scip_con; + PyObject *__pyx_n_s_scip_cons; + PyObject *__pyx_n_s_scip_conshdlr; + PyObject *__pyx_n_s_scip_expr; + PyObject *__pyx_n_s_scip_pricer; + PyObject *__pyx_n_s_scip_sepa; + PyObject *__pyx_n_s_scip_sol; + PyObject *__pyx_n_s_scip_subprob; + PyObject *__pyx_n_s_scip_var; + PyObject *__pyx_n_s_scipexprs; + PyObject *__pyx_n_s_scipvar1; + PyObject *__pyx_n_s_scipvar2; + PyObject *__pyx_n_s_self; + PyObject *__pyx_kp_s_self__benders_cannot_be_converte; + PyObject *__pyx_kp_s_self__scip_self__valid_cannot_be; + PyObject *__pyx_kp_s_self_event_cannot_be_converted_t; + PyObject *__pyx_kp_s_self_lpi_cannot_be_converted_to; + PyObject *__pyx_kp_s_self_scip_boundchg_cannot_be_con; + PyObject *__pyx_kp_s_self_scip_col_cannot_be_converte; + PyObject *__pyx_kp_s_self_scip_cons_cannot_be_convert; + PyObject *__pyx_kp_s_self_scip_domchg_cannot_be_conve; + PyObject *__pyx_kp_s_self_scip_nlrow_cannot_be_conver; + PyObject *__pyx_kp_s_self_scip_node_cannot_be_convert; + PyObject *__pyx_kp_s_self_scip_row_cannot_be_converte; + PyObject *__pyx_kp_s_self_scip_self_sol_cannot_be_con; + PyObject *__pyx_kp_s_self_scip_var_cannot_be_converte; + PyObject *__pyx_n_u_selnode; + PyObject *__pyx_n_s_send; + PyObject *__pyx_n_s_sense; + PyObject *__pyx_n_s_sepa; + PyObject *__pyx_n_s_sepaexeclp; + PyObject *__pyx_n_s_sepaexecsol; + PyObject *__pyx_n_s_sepaexit; + PyObject *__pyx_n_s_sepaexitsol; + PyObject *__pyx_n_s_sepafree; + PyObject *__pyx_n_s_sepafreq; + PyObject *__pyx_n_s_sepainit; + PyObject *__pyx_n_s_sepainitsol; + PyObject *__pyx_n_s_sepapriority; + PyObject *__pyx_n_s_separate; + PyObject *__pyx_n_u_separate; + PyObject *__pyx_n_s_separateSol; + PyObject *__pyx_n_s_setBendersSubproblemIsConvex; + PyObject *__pyx_n_s_setBoolParam; + PyObject *__pyx_n_s_setCharParam; + PyObject *__pyx_n_s_setCheck; + PyObject *__pyx_n_s_setEmphasis; + PyObject *__pyx_n_s_setEnforced; + PyObject *__pyx_n_s_setHeuristics; + PyObject *__pyx_n_s_setInitial; + PyObject *__pyx_n_s_setIntParam; + PyObject *__pyx_n_s_setLogfile; + PyObject *__pyx_n_s_setLongintParam; + PyObject *__pyx_n_s_setMaximize; + PyObject *__pyx_n_s_setMinimize; + PyObject *__pyx_n_s_setObjIntegral; + PyObject *__pyx_n_s_setObjective; + PyObject *__pyx_n_s_setObjlimit; + PyObject *__pyx_n_s_setParam; + PyObject *__pyx_n_s_setParams; + PyObject *__pyx_n_s_setParamsCountsols; + PyObject *__pyx_n_s_setPresolve; + PyObject *__pyx_n_s_setProbName; + PyObject *__pyx_n_s_setRealParam; + PyObject *__pyx_n_s_setRelaxSolVal; + PyObject *__pyx_n_s_setRemovable; + PyObject *__pyx_n_s_setSeparating; + PyObject *__pyx_n_s_setSolVal; + PyObject *__pyx_n_s_setStringParam; + PyObject *__pyx_n_s_set_name; + PyObject *__pyx_n_s_setlocale; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_setting; + PyObject *__pyx_n_s_setupBendersSubproblem; + PyObject *__pyx_n_s_shareaux; + PyObject *__pyx_n_s_siblings; + PyObject *__pyx_n_s_siblings_2; + PyObject *__pyx_n_s_side; + PyObject *__pyx_n_s_sin; + PyObject *__pyx_n_u_sin; + PyObject *__pyx_n_u_skipsolve; + PyObject *__pyx_n_s_slots; + PyObject *__pyx_n_s_sol; + PyObject *__pyx_n_s_sol_2; + PyObject *__pyx_n_s_solinfeasible; + PyObject *__pyx_n_u_sollimit; + PyObject *__pyx_n_s_solptr; + PyObject *__pyx_n_s_sols; + PyObject *__pyx_n_s_sols_2; + PyObject *__pyx_n_s_solution; + PyObject *__pyx_n_s_solutions; + PyObject *__pyx_n_s_solve; + PyObject *__pyx_n_s_solveBendersSubproblem; + PyObject *__pyx_n_s_solveConcurrent; + PyObject *__pyx_n_s_solveDiveLP; + PyObject *__pyx_n_s_solveProbingLP; + PyObject *__pyx_n_s_solvecip; + PyObject *__pyx_n_s_sorted; + PyObject *__pyx_n_s_sourceModel; + PyObject *__pyx_n_s_sourceconstraint; + PyObject *__pyx_n_s_spec; + PyObject *__pyx_n_s_splitext; + PyObject *__pyx_n_s_sqrcoef; + PyObject *__pyx_n_s_sqrexpr; + PyObject *__pyx_n_s_sqrt; + PyObject *__pyx_n_u_sqrt; + PyObject *__pyx_kp_s_src_pyscipopt_benders_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_benderscut_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_branchrule_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_conshdlr_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_cutsel_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_event_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_expr_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_heuristic_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_lp_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_nodesel_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_presol_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_pricer_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_propagator_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_reader_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_relax_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_scip_pxi; + PyObject *__pyx_kp_s_src_pyscipopt_sepa_pxi; + PyObject *__pyx_n_u_stallnodelimit; + PyObject *__pyx_n_s_startDive; + PyObject *__pyx_n_s_startProbing; + PyObject *__pyx_n_s_startnconss; + PyObject *__pyx_n_s_startnvars; + PyObject *__pyx_n_s_stat; + PyObject *__pyx_n_s_state; + PyObject *__pyx_n_s_staticmethod; + PyObject *__pyx_n_s_stderr; + PyObject *__pyx_n_s_stdout; + PyObject *__pyx_n_s_stdpriority; + PyObject *__pyx_n_s_stickingatnode; + PyObject *__pyx_n_u_stickingatnode; + PyObject *__pyx_n_u_stopearly; + PyObject *__pyx_n_s_stored; + PyObject *__pyx_n_s_str_absfile; + PyObject *__pyx_n_s_str_conversion; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_subprob; + PyObject *__pyx_n_s_subproblem; + PyObject *__pyx_n_s_subproblems; + PyObject *__pyx_n_s_subprobs; + PyObject *__pyx_n_s_success; + PyObject *__pyx_n_u_success; + PyObject *__pyx_n_s_sum; + PyObject *__pyx_n_u_sum; + PyObject *__pyx_n_s_sumexpr; + PyObject *__pyx_n_s_super; + PyObject *__pyx_n_s_sys; + PyObject *__pyx_n_s_t; + PyObject *__pyx_n_s_take_ownership; + PyObject *__pyx_n_u_targetcons; + PyObject *__pyx_n_s_targetvalue; + PyObject *__pyx_n_s_temp_cons; + PyObject *__pyx_n_s_term; + PyObject *__pyx_kp_u_term_length_must_be_1_or_2_but_i; + PyObject *__pyx_n_s_termcoefs; + PyObject *__pyx_n_s_termidx; + PyObject *__pyx_n_s_termlist; + PyObject *__pyx_n_s_terms; + PyObject *__pyx_n_s_termvars; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_threadsafe; + PyObject *__pyx_n_s_throw; + PyObject *__pyx_n_s_tightenVarLb; + PyObject *__pyx_n_s_tightenVarLbGlobal; + PyObject *__pyx_n_s_tightenVarUb; + PyObject *__pyx_n_s_tightenVarUbGlobal; + PyObject *__pyx_n_s_tightened; + PyObject *__pyx_n_u_timelimit; + PyObject *__pyx_n_s_timing; + PyObject *__pyx_n_s_timingmask; + PyObject *__pyx_n_s_tmp; + PyObject *__pyx_n_s_to_ptr; + PyObject *__pyx_kp_u_total_number_of_solutions_found; + PyObject *__pyx_n_u_totalnodelimit; + PyObject *__pyx_n_s_trans; + PyObject *__pyx_n_s_transcons; + PyObject *__pyx_n_s_transformed; + PyObject *__pyx_kp_u_transprob_sol; + PyObject *__pyx_n_u_true; + PyObject *__pyx_n_s_truediv; + PyObject *__pyx_n_s_trySol; + PyObject *__pyx_n_s_tvar; + PyObject *__pyx_n_s_typing; + PyObject *__pyx_n_s_ub; + PyObject *__pyx_n_s_ubs; + PyObject *__pyx_n_u_unbounded; + PyObject *__pyx_n_u_unknown; + PyObject *__pyx_kp_u_unrecognized_objective_sense; + PyObject *__pyx_kp_u_unrecognized_optimization_sense; + PyObject *__pyx_kp_u_unrecognized_variable_type; + PyObject *__pyx_n_s_upchild; + PyObject *__pyx_n_s_update; + PyObject *__pyx_n_s_updateBendersLowerbounds; + PyObject *__pyx_n_s_updateNodeLowerbound; + PyObject *__pyx_n_s_upper; + PyObject *__pyx_n_u_upper; + PyObject *__pyx_n_s_use_setstate; + PyObject *__pyx_n_s_user_locale; + PyObject *__pyx_n_u_userinterrupt; + PyObject *__pyx_n_s_usessubscip; + PyObject *__pyx_kp_u_utf_8; + PyObject *__pyx_n_s_v; + PyObject *__pyx_n_s_val; + PyObject *__pyx_n_s_val1; + PyObject *__pyx_n_s_val2; + PyObject *__pyx_n_s_valid; + PyObject *__pyx_n_s_validnode; + PyObject *__pyx_n_s_vals; + PyObject *__pyx_n_s_vals_2; + PyObject *__pyx_n_s_valsdict; + PyObject *__pyx_n_s_value; + PyObject *__pyx_n_s_value_to_array; + PyObject *__pyx_n_s_valuenode; + PyObject *__pyx_n_s_values; + PyObject *__pyx_n_s_var; + PyObject *__pyx_n_u_var; + PyObject *__pyx_n_s_var1; + PyObject *__pyx_n_s_var2; + PyObject *__pyx_n_s_var_2; + PyObject *__pyx_n_s_var_dict; + PyObject *__pyx_n_s_varexpr; + PyObject *__pyx_n_s_varexprs; + PyObject *__pyx_n_s_variable; + PyObject *__pyx_n_s_variables; + PyObject *__pyx_n_s_varidx; + PyObject *__pyx_n_s_varindex; + PyObject *__pyx_n_s_varpos; + PyObject *__pyx_n_s_vars; + PyObject *__pyx_n_s_vars_2; + PyObject *__pyx_n_s_vars_array; + PyObject *__pyx_n_s_vartuple; + PyObject *__pyx_n_u_vartuple; + PyObject *__pyx_n_s_vartype; + PyObject *__pyx_n_s_verbose; + PyObject *__pyx_n_s_version; + PyObject *__pyx_n_s_version_info; + PyObject *__pyx_n_s_vtype; + PyObject *__pyx_n_u_w; + PyObject *__pyx_n_s_warn; + PyObject *__pyx_n_s_warnings; + PyObject *__pyx_n_s_weakref; + PyObject *__pyx_n_s_weight; + PyObject *__pyx_n_s_weights; + PyObject *__pyx_n_s_write; + PyObject *__pyx_n_s_writeBestSol; + PyObject *__pyx_n_s_writeBestTransSol; + PyObject *__pyx_n_s_writeLP; + PyObject *__pyx_n_s_writeName; + PyObject *__pyx_n_s_writeParams; + PyObject *__pyx_n_s_writeProblem; + PyObject *__pyx_n_s_writeSol; + PyObject *__pyx_n_s_writeStatistics; + PyObject *__pyx_n_s_writeTransSol; + PyObject *__pyx_n_s_write_zeros; + PyObject *__pyx_kp_u_wrote_parameter_settings_to_file; + PyObject *__pyx_kp_u_wrote_problem_to_file; + PyObject *__pyx_n_s_x; + PyObject *__pyx_n_u_x; + PyObject *__pyx_n_u_zero; + PyObject *__pyx_float_0_0; + PyObject *__pyx_float_1_0; + PyObject *__pyx_float_10_0; + PyObject *__pyx_float_100_0; + PyObject *__pyx_float_1e_20; + PyObject *__pyx_float_neg_1_0; + PyObject *__pyx_int_0; + PyObject *__pyx_int_1; + PyObject *__pyx_int_2; + PyObject *__pyx_int_3; + PyObject *__pyx_int_5; + PyObject *__pyx_int_9; + PyObject *__pyx_int_10; + PyObject *__pyx_int_100; + PyObject *__pyx_int_101; + PyObject *__pyx_int_10000; + PyObject *__pyx_int_13758880; + PyObject *__pyx_int_25280761; + PyObject *__pyx_int_30435853; + PyObject *__pyx_int_34551270; + PyObject *__pyx_int_37557029; + PyObject *__pyx_int_63254455; + PyObject *__pyx_int_76513566; + PyObject *__pyx_int_76998962; + PyObject *__pyx_int_80720285; + PyObject *__pyx_int_85795681; + PyObject *__pyx_int_95355963; + PyObject *__pyx_int_114651189; + PyObject *__pyx_int_116691903; + PyObject *__pyx_int_132603380; + PyObject *__pyx_int_135158539; + PyObject *__pyx_int_143015212; + PyObject *__pyx_int_147635180; + PyObject *__pyx_int_150239579; + PyObject *__pyx_int_152146234; + PyObject *__pyx_int_154610759; + PyObject *__pyx_int_169888372; + PyObject *__pyx_int_173957064; + PyObject *__pyx_int_176834982; + PyObject *__pyx_int_201230365; + PyObject *__pyx_int_204489503; + PyObject *__pyx_int_208012509; + PyObject *__pyx_int_208195651; + PyObject *__pyx_int_214626690; + PyObject *__pyx_int_216408278; + PyObject *__pyx_int_222419149; + PyObject *__pyx_int_228825662; + PyObject *__pyx_int_238750788; + PyObject *__pyx_int_240430858; + PyObject *__pyx_int_248330301; + PyObject *__pyx_int_253686829; + PyObject *__pyx_int_267356384; + PyObject *__pyx_int_neg_1; + PyObject *__pyx_k__101; + PyObject *__pyx_k__102; + PyObject *__pyx_k__103; + PyObject *__pyx_k__104; + PyObject *__pyx_k__105; + PyObject *__pyx_k__106; + PyObject *__pyx_tuple_; + PyObject *__pyx_tuple__3; + PyObject *__pyx_tuple__4; + PyObject *__pyx_tuple__5; + PyObject *__pyx_tuple__7; + PyObject *__pyx_tuple__8; + PyObject *__pyx_slice__88; + PyObject *__pyx_tuple__11; + PyObject *__pyx_tuple__12; + PyObject *__pyx_tuple__13; + PyObject *__pyx_tuple__14; + PyObject *__pyx_tuple__15; + PyObject *__pyx_tuple__16; + PyObject *__pyx_tuple__17; + PyObject *__pyx_tuple__18; + PyObject *__pyx_tuple__19; + PyObject *__pyx_tuple__20; + PyObject *__pyx_tuple__21; + PyObject *__pyx_tuple__22; + PyObject *__pyx_tuple__23; + PyObject *__pyx_tuple__24; + PyObject *__pyx_tuple__25; + PyObject *__pyx_tuple__26; + PyObject *__pyx_tuple__27; + PyObject *__pyx_tuple__28; + PyObject *__pyx_tuple__29; + PyObject *__pyx_tuple__30; + PyObject *__pyx_tuple__31; + PyObject *__pyx_tuple__32; + PyObject *__pyx_tuple__33; + PyObject *__pyx_tuple__34; + PyObject *__pyx_tuple__35; + PyObject *__pyx_tuple__36; + PyObject *__pyx_tuple__37; + PyObject *__pyx_tuple__38; + PyObject *__pyx_tuple__39; + PyObject *__pyx_tuple__40; + PyObject *__pyx_tuple__41; + PyObject *__pyx_tuple__42; + PyObject *__pyx_tuple__43; + PyObject *__pyx_tuple__44; + PyObject *__pyx_tuple__45; + PyObject *__pyx_tuple__46; + PyObject *__pyx_tuple__47; + PyObject *__pyx_tuple__48; + PyObject *__pyx_tuple__49; + PyObject *__pyx_tuple__50; + PyObject *__pyx_tuple__51; + PyObject *__pyx_tuple__52; + PyObject *__pyx_tuple__53; + PyObject *__pyx_tuple__54; + PyObject *__pyx_tuple__55; + PyObject *__pyx_tuple__56; + PyObject *__pyx_tuple__57; + PyObject *__pyx_tuple__58; + PyObject *__pyx_tuple__59; + PyObject *__pyx_tuple__60; + PyObject *__pyx_tuple__61; + PyObject *__pyx_tuple__62; + PyObject *__pyx_tuple__63; + PyObject *__pyx_tuple__64; + PyObject *__pyx_tuple__65; + PyObject *__pyx_tuple__66; + PyObject *__pyx_tuple__67; + PyObject *__pyx_tuple__68; + PyObject *__pyx_tuple__69; + PyObject *__pyx_tuple__70; + PyObject *__pyx_tuple__71; + PyObject *__pyx_tuple__72; + PyObject *__pyx_tuple__73; + PyObject *__pyx_tuple__74; + PyObject *__pyx_tuple__75; + PyObject *__pyx_tuple__76; + PyObject *__pyx_tuple__77; + PyObject *__pyx_tuple__78; + PyObject *__pyx_tuple__80; + PyObject *__pyx_tuple__81; + PyObject *__pyx_tuple__82; + PyObject *__pyx_tuple__83; + PyObject *__pyx_tuple__84; + PyObject *__pyx_tuple__85; + PyObject *__pyx_tuple__86; + PyObject *__pyx_tuple__87; + PyObject *__pyx_tuple__90; + PyObject *__pyx_tuple__91; + PyObject *__pyx_tuple__92; + PyObject *__pyx_tuple__96; + PyObject *__pyx_tuple__97; + PyObject *__pyx_tuple__98; + PyObject *__pyx_tuple__99; + PyObject *__pyx_tuple__100; + PyObject *__pyx_tuple__107; + PyObject *__pyx_tuple__108; + PyObject *__pyx_tuple__109; + PyObject *__pyx_tuple__110; + PyObject *__pyx_tuple__111; + PyObject *__pyx_tuple__112; + PyObject *__pyx_tuple__113; + PyObject *__pyx_tuple__115; + PyObject *__pyx_tuple__116; + PyObject *__pyx_tuple__117; + PyObject *__pyx_tuple__118; + PyObject *__pyx_tuple__119; + PyObject *__pyx_tuple__120; + PyObject *__pyx_tuple__121; + PyObject *__pyx_tuple__122; + PyObject *__pyx_tuple__123; + PyObject *__pyx_tuple__124; + PyObject *__pyx_tuple__125; + PyObject *__pyx_tuple__127; + PyObject *__pyx_tuple__129; + PyObject *__pyx_tuple__131; + PyObject *__pyx_tuple__132; + PyObject *__pyx_tuple__134; + PyObject *__pyx_tuple__136; + PyObject *__pyx_tuple__138; + PyObject *__pyx_tuple__141; + PyObject *__pyx_tuple__143; + PyObject *__pyx_tuple__145; + PyObject *__pyx_tuple__147; + PyObject *__pyx_tuple__149; + PyObject *__pyx_tuple__151; + PyObject *__pyx_tuple__153; + PyObject *__pyx_tuple__155; + PyObject *__pyx_tuple__159; + PyObject *__pyx_tuple__182; + PyObject *__pyx_tuple__188; + PyObject *__pyx_tuple__190; + PyObject *__pyx_tuple__192; + PyObject *__pyx_tuple__194; + PyObject *__pyx_tuple__198; + PyObject *__pyx_tuple__200; + PyObject *__pyx_tuple__202; + PyObject *__pyx_tuple__203; + PyObject *__pyx_tuple__205; + PyObject *__pyx_tuple__207; + PyObject *__pyx_tuple__209; + PyObject *__pyx_tuple__210; + PyObject *__pyx_tuple__212; + PyObject *__pyx_tuple__213; + PyObject *__pyx_tuple__215; + PyObject *__pyx_tuple__217; + PyObject *__pyx_tuple__218; + PyObject *__pyx_tuple__220; + PyObject *__pyx_tuple__222; + PyObject *__pyx_tuple__224; + PyObject *__pyx_tuple__226; + PyObject *__pyx_tuple__229; + PyObject *__pyx_tuple__231; + PyObject *__pyx_tuple__233; + PyObject *__pyx_tuple__235; + PyObject *__pyx_tuple__238; + PyObject *__pyx_tuple__241; + PyObject *__pyx_tuple__243; + PyObject *__pyx_tuple__245; + PyObject *__pyx_tuple__247; + PyObject *__pyx_tuple__249; + PyObject *__pyx_tuple__260; + PyObject *__pyx_tuple__262; + PyObject *__pyx_tuple__264; + PyObject *__pyx_tuple__266; + PyObject *__pyx_tuple__268; + PyObject *__pyx_tuple__271; + PyObject *__pyx_tuple__280; + PyObject *__pyx_tuple__289; + PyObject *__pyx_tuple__296; + PyObject *__pyx_tuple__302; + PyObject *__pyx_tuple__304; + PyObject *__pyx_tuple__306; + PyObject *__pyx_tuple__309; + PyObject *__pyx_tuple__311; + PyObject *__pyx_tuple__313; + PyObject *__pyx_tuple__315; + PyObject *__pyx_tuple__317; + PyObject *__pyx_tuple__319; + PyObject *__pyx_tuple__321; + PyObject *__pyx_tuple__323; + PyObject *__pyx_tuple__326; + PyObject *__pyx_tuple__348; + PyObject *__pyx_tuple__359; + PyObject *__pyx_tuple__368; + PyObject *__pyx_tuple__377; + PyObject *__pyx_tuple__394; + PyObject *__pyx_tuple__398; + PyObject *__pyx_tuple__400; + PyObject *__pyx_tuple__402; + PyObject *__pyx_tuple__412; + PyObject *__pyx_tuple__418; + PyObject *__pyx_tuple__436; + PyObject *__pyx_tuple__440; + PyObject *__pyx_tuple__471; + PyObject *__pyx_tuple__475; + PyObject *__pyx_tuple__479; + PyObject *__pyx_tuple__481; + PyObject *__pyx_tuple__483; + PyObject *__pyx_tuple__488; + PyObject *__pyx_tuple__509; + PyObject *__pyx_tuple__513; + PyObject *__pyx_tuple__515; + PyObject *__pyx_tuple__521; + PyObject *__pyx_tuple__528; + PyObject *__pyx_tuple__530; + PyObject *__pyx_tuple__541; + PyObject *__pyx_tuple__551; + PyObject *__pyx_tuple__556; + PyObject *__pyx_tuple__558; + PyObject *__pyx_tuple__560; + PyObject *__pyx_tuple__562; + PyObject *__pyx_tuple__567; + PyObject *__pyx_tuple__572; + PyObject *__pyx_tuple__596; + PyObject *__pyx_tuple__602; + PyObject *__pyx_tuple__604; + PyObject *__pyx_tuple__607; + PyObject *__pyx_tuple__609; + PyObject *__pyx_tuple__611; + PyObject *__pyx_tuple__614; + PyObject *__pyx_tuple__636; + PyObject *__pyx_tuple__644; + PyObject *__pyx_tuple__651; + PyObject *__pyx_tuple__653; + PyObject *__pyx_tuple__654; + PyObject *__pyx_tuple__656; + PyObject *__pyx_tuple__660; + PyObject *__pyx_tuple__663; + PyObject *__pyx_tuple__665; + PyObject *__pyx_tuple__666; + PyObject *__pyx_tuple__668; + PyObject *__pyx_tuple__670; + PyObject *__pyx_tuple__674; + PyObject *__pyx_tuple__676; + PyObject *__pyx_tuple__680; + PyObject *__pyx_tuple__682; + PyObject *__pyx_tuple__684; + PyObject *__pyx_tuple__685; + PyObject *__pyx_tuple__687; + PyObject *__pyx_tuple__688; + PyObject *__pyx_tuple__690; + PyObject *__pyx_tuple__692; + PyObject *__pyx_tuple__694; + PyObject *__pyx_tuple__696; + PyObject *__pyx_tuple__698; + PyObject *__pyx_tuple__702; + PyObject *__pyx_tuple__704; + PyObject *__pyx_tuple__708; + PyObject *__pyx_tuple__710; + PyObject *__pyx_tuple__712; + PyObject *__pyx_tuple__714; + PyObject *__pyx_tuple__716; + PyObject *__pyx_tuple__720; + PyObject *__pyx_tuple__722; + PyObject *__pyx_tuple__730; + PyObject *__pyx_tuple__734; + PyObject *__pyx_tuple__737; + PyObject *__pyx_tuple__739; + PyObject *__pyx_tuple__743; + PyObject *__pyx_tuple__745; + PyObject *__pyx_tuple__747; + PyObject *__pyx_tuple__750; + PyObject *__pyx_tuple__752; + PyObject *__pyx_tuple__753; + PyObject *__pyx_tuple__760; + PyObject *__pyx_tuple__765; + PyObject *__pyx_tuple__767; + PyObject *__pyx_tuple__770; + PyObject *__pyx_tuple__772; + PyObject *__pyx_tuple__775; + PyObject *__pyx_tuple__780; + PyObject *__pyx_tuple__782; + PyObject *__pyx_tuple__783; + PyObject *__pyx_tuple__785; + PyObject *__pyx_tuple__787; + PyObject *__pyx_tuple__789; + PyObject *__pyx_tuple__791; + PyObject *__pyx_tuple__793; + PyObject *__pyx_tuple__794; + PyObject *__pyx_tuple__796; + PyObject *__pyx_tuple__798; + PyObject *__pyx_tuple__800; + PyObject *__pyx_tuple__801; + PyObject *__pyx_tuple__803; + PyObject *__pyx_tuple__805; + PyObject *__pyx_tuple__808; + PyObject *__pyx_tuple__810; + PyObject *__pyx_tuple__812; + PyObject *__pyx_tuple__814; + PyObject *__pyx_tuple__816; + PyObject *__pyx_tuple__818; + PyObject *__pyx_tuple__820; + PyObject *__pyx_tuple__821; + PyObject *__pyx_tuple__823; + PyObject *__pyx_tuple__825; + PyObject *__pyx_tuple__826; + PyObject *__pyx_tuple__828; + PyObject *__pyx_tuple__829; + PyObject *__pyx_tuple__831; + PyObject *__pyx_tuple__832; + PyObject *__pyx_tuple__834; + PyObject *__pyx_tuple__835; + PyObject *__pyx_tuple__837; + PyObject *__pyx_tuple__839; + PyObject *__pyx_tuple__844; + PyObject *__pyx_tuple__846; + PyObject *__pyx_tuple__848; + PyObject *__pyx_tuple__850; + PyObject *__pyx_tuple__852; + PyObject *__pyx_tuple__854; + PyObject *__pyx_tuple__856; + PyObject *__pyx_tuple__859; + PyObject *__pyx_tuple__863; + PyObject *__pyx_tuple__865; + PyObject *__pyx_tuple__867; + PyObject *__pyx_tuple__871; + PyObject *__pyx_tuple__873; + PyObject *__pyx_tuple__875; + PyObject *__pyx_tuple__877; + PyObject *__pyx_tuple__879; + PyObject *__pyx_tuple__881; + PyObject *__pyx_tuple__883; + PyObject *__pyx_tuple__885; + PyObject *__pyx_tuple__887; + PyObject *__pyx_tuple__892; + PyObject *__pyx_tuple__894; + PyObject *__pyx_tuple__896; + PyObject *__pyx_tuple__900; + PyObject *__pyx_tuple__902; + PyObject *__pyx_tuple__907; + PyObject *__pyx_tuple__909; + PyObject *__pyx_tuple__911; + PyObject *__pyx_tuple__913; + PyObject *__pyx_tuple__915; + PyObject *__pyx_tuple__917; + PyObject *__pyx_tuple__919; + PyObject *__pyx_tuple__921; + PyObject *__pyx_tuple__923; + PyObject *__pyx_tuple__925; + PyObject *__pyx_tuple__927; + PyObject *__pyx_tuple__929; + PyObject *__pyx_tuple__930; + PyObject *__pyx_tuple__932; + PyObject *__pyx_tuple__934; + PyObject *__pyx_tuple__936; + PyObject *__pyx_tuple__938; + PyObject *__pyx_tuple__940; + PyObject *__pyx_tuple__941; + PyObject *__pyx_tuple__943; + PyObject *__pyx_tuple__945; + PyObject *__pyx_tuple__946; + PyObject *__pyx_tuple__948; + PyObject *__pyx_tuple__950; + PyObject *__pyx_tuple__951; + PyObject *__pyx_tuple__953; + PyObject *__pyx_tuple__955; + PyObject *__pyx_tuple__957; + PyObject *__pyx_tuple__959; + PyObject *__pyx_tuple__960; + PyObject *__pyx_tuple__962; + PyObject *__pyx_tuple__964; + PyObject *__pyx_tuple__966; + PyObject *__pyx_tuple__968; + PyObject *__pyx_tuple__969; + PyObject *__pyx_tuple__971; + PyObject *__pyx_tuple__973; + PyObject *__pyx_tuple__975; + PyObject *__pyx_tuple__977; + PyObject *__pyx_tuple__979; + PyObject *__pyx_tuple__981; + PyObject *__pyx_tuple__983; + PyObject *__pyx_tuple__987; + PyObject *__pyx_tuple__989; + PyObject *__pyx_tuple__994; + PyObject *__pyx_tuple__996; + PyObject *__pyx_tuple__999; + PyObject *__pyx_codeobj__93; + PyObject *__pyx_codeobj__95; + PyObject *__pyx_tuple__1001; + PyObject *__pyx_tuple__1006; + PyObject *__pyx_tuple__1012; + PyObject *__pyx_tuple__1018; + PyObject *__pyx_tuple__1022; + PyObject *__pyx_tuple__1024; + PyObject *__pyx_tuple__1025; + PyObject *__pyx_tuple__1027; + PyObject *__pyx_tuple__1030; + PyObject *__pyx_tuple__1032; + PyObject *__pyx_tuple__1034; + PyObject *__pyx_tuple__1035; + PyObject *__pyx_tuple__1037; + PyObject *__pyx_tuple__1039; + PyObject *__pyx_tuple__1040; + PyObject *__pyx_tuple__1044; + PyObject *__pyx_tuple__1046; + PyObject *__pyx_tuple__1048; + PyObject *__pyx_tuple__1050; + PyObject *__pyx_tuple__1051; + PyObject *__pyx_tuple__1053; + PyObject *__pyx_tuple__1054; + PyObject *__pyx_tuple__1061; + PyObject *__pyx_tuple__1064; + PyObject *__pyx_tuple__1066; + PyObject *__pyx_tuple__1069; + PyObject *__pyx_tuple__1071; + PyObject *__pyx_tuple__1075; + PyObject *__pyx_tuple__1080; + PyObject *__pyx_tuple__1086; + PyObject *__pyx_tuple__1088; + PyObject *__pyx_tuple__1091; + PyObject *__pyx_tuple__1094; + PyObject *__pyx_tuple__1098; + PyObject *__pyx_tuple__1100; + PyObject *__pyx_tuple__1102; + PyObject *__pyx_tuple__1104; + PyObject *__pyx_tuple__1106; + PyObject *__pyx_tuple__1108; + PyObject *__pyx_tuple__1114; + PyObject *__pyx_tuple__1116; + PyObject *__pyx_tuple__1118; + PyObject *__pyx_tuple__1120; + PyObject *__pyx_tuple__1122; + PyObject *__pyx_tuple__1124; + PyObject *__pyx_tuple__1126; + PyObject *__pyx_tuple__1128; + PyObject *__pyx_tuple__1131; + PyObject *__pyx_tuple__1133; + PyObject *__pyx_tuple__1137; + PyObject *__pyx_tuple__1141; + PyObject *__pyx_tuple__1143; + PyObject *__pyx_tuple__1144; + PyObject *__pyx_tuple__1151; + PyObject *__pyx_codeobj__128; + PyObject *__pyx_codeobj__130; + PyObject *__pyx_codeobj__133; + PyObject *__pyx_codeobj__135; + PyObject *__pyx_codeobj__137; + PyObject *__pyx_codeobj__139; + PyObject *__pyx_codeobj__140; + PyObject *__pyx_codeobj__142; + PyObject *__pyx_codeobj__144; + PyObject *__pyx_codeobj__146; + PyObject *__pyx_codeobj__148; + PyObject *__pyx_codeobj__150; + PyObject *__pyx_codeobj__152; + PyObject *__pyx_codeobj__154; + PyObject *__pyx_codeobj__156; + PyObject *__pyx_codeobj__157; + PyObject *__pyx_codeobj__158; + PyObject *__pyx_codeobj__160; + PyObject *__pyx_codeobj__161; + PyObject *__pyx_codeobj__166; + PyObject *__pyx_codeobj__167; + PyObject *__pyx_codeobj__168; + PyObject *__pyx_codeobj__169; + PyObject *__pyx_codeobj__170; + PyObject *__pyx_codeobj__171; + PyObject *__pyx_codeobj__172; + PyObject *__pyx_codeobj__173; + PyObject *__pyx_codeobj__174; + PyObject *__pyx_codeobj__175; + PyObject *__pyx_codeobj__176; + PyObject *__pyx_codeobj__177; + PyObject *__pyx_codeobj__178; + PyObject *__pyx_codeobj__179; + PyObject *__pyx_codeobj__180; + PyObject *__pyx_codeobj__181; + PyObject *__pyx_codeobj__183; + PyObject *__pyx_codeobj__184; + PyObject *__pyx_codeobj__185; + PyObject *__pyx_codeobj__186; + PyObject *__pyx_codeobj__187; + PyObject *__pyx_codeobj__189; + PyObject *__pyx_codeobj__191; + PyObject *__pyx_codeobj__193; + PyObject *__pyx_codeobj__195; + PyObject *__pyx_codeobj__196; + PyObject *__pyx_codeobj__197; + PyObject *__pyx_codeobj__199; + PyObject *__pyx_codeobj__201; + PyObject *__pyx_codeobj__204; + PyObject *__pyx_codeobj__206; + PyObject *__pyx_codeobj__208; + PyObject *__pyx_codeobj__211; + PyObject *__pyx_codeobj__214; + PyObject *__pyx_codeobj__216; + PyObject *__pyx_codeobj__219; + PyObject *__pyx_codeobj__221; + PyObject *__pyx_codeobj__223; + PyObject *__pyx_codeobj__225; + PyObject *__pyx_codeobj__227; + PyObject *__pyx_codeobj__228; + PyObject *__pyx_codeobj__230; + PyObject *__pyx_codeobj__232; + PyObject *__pyx_codeobj__234; + PyObject *__pyx_codeobj__236; + PyObject *__pyx_codeobj__237; + PyObject *__pyx_codeobj__239; + PyObject *__pyx_codeobj__240; + PyObject *__pyx_codeobj__242; + PyObject *__pyx_codeobj__244; + PyObject *__pyx_codeobj__246; + PyObject *__pyx_codeobj__248; + PyObject *__pyx_codeobj__250; + PyObject *__pyx_codeobj__251; + PyObject *__pyx_codeobj__252; + PyObject *__pyx_codeobj__253; + PyObject *__pyx_codeobj__254; + PyObject *__pyx_codeobj__255; + PyObject *__pyx_codeobj__256; + PyObject *__pyx_codeobj__257; + PyObject *__pyx_codeobj__258; + PyObject *__pyx_codeobj__259; + PyObject *__pyx_codeobj__261; + PyObject *__pyx_codeobj__263; + PyObject *__pyx_codeobj__265; + PyObject *__pyx_codeobj__267; + PyObject *__pyx_codeobj__269; + PyObject *__pyx_codeobj__270; + PyObject *__pyx_codeobj__272; + PyObject *__pyx_codeobj__273; + PyObject *__pyx_codeobj__274; + PyObject *__pyx_codeobj__275; + PyObject *__pyx_codeobj__276; + PyObject *__pyx_codeobj__277; + PyObject *__pyx_codeobj__278; + PyObject *__pyx_codeobj__279; + PyObject *__pyx_codeobj__281; + PyObject *__pyx_codeobj__282; + PyObject *__pyx_codeobj__283; + PyObject *__pyx_codeobj__284; + PyObject *__pyx_codeobj__285; + PyObject *__pyx_codeobj__286; + PyObject *__pyx_codeobj__287; + PyObject *__pyx_codeobj__288; + PyObject *__pyx_codeobj__290; + PyObject *__pyx_codeobj__291; + PyObject *__pyx_codeobj__292; + PyObject *__pyx_codeobj__293; + PyObject *__pyx_codeobj__294; + PyObject *__pyx_codeobj__295; + PyObject *__pyx_codeobj__297; + PyObject *__pyx_codeobj__298; + PyObject *__pyx_codeobj__299; + PyObject *__pyx_codeobj__300; + PyObject *__pyx_codeobj__301; + PyObject *__pyx_codeobj__303; + PyObject *__pyx_codeobj__305; + PyObject *__pyx_codeobj__307; + PyObject *__pyx_codeobj__308; + PyObject *__pyx_codeobj__310; + PyObject *__pyx_codeobj__312; + PyObject *__pyx_codeobj__314; + PyObject *__pyx_codeobj__316; + PyObject *__pyx_codeobj__318; + PyObject *__pyx_codeobj__320; + PyObject *__pyx_codeobj__322; + PyObject *__pyx_codeobj__324; + PyObject *__pyx_codeobj__325; + PyObject *__pyx_codeobj__327; + PyObject *__pyx_codeobj__328; + PyObject *__pyx_codeobj__329; + PyObject *__pyx_codeobj__330; + PyObject *__pyx_codeobj__331; + PyObject *__pyx_codeobj__332; + PyObject *__pyx_codeobj__333; + PyObject *__pyx_codeobj__334; + PyObject *__pyx_codeobj__335; + PyObject *__pyx_codeobj__336; + PyObject *__pyx_codeobj__337; + PyObject *__pyx_codeobj__338; + PyObject *__pyx_codeobj__339; + PyObject *__pyx_codeobj__340; + PyObject *__pyx_codeobj__341; + PyObject *__pyx_codeobj__342; + PyObject *__pyx_codeobj__343; + PyObject *__pyx_codeobj__344; + PyObject *__pyx_codeobj__345; + PyObject *__pyx_codeobj__346; + PyObject *__pyx_codeobj__347; + PyObject *__pyx_codeobj__349; + PyObject *__pyx_codeobj__350; + PyObject *__pyx_codeobj__351; + PyObject *__pyx_codeobj__352; + PyObject *__pyx_codeobj__353; + PyObject *__pyx_codeobj__354; + PyObject *__pyx_codeobj__355; + PyObject *__pyx_codeobj__356; + PyObject *__pyx_codeobj__357; + PyObject *__pyx_codeobj__358; + PyObject *__pyx_codeobj__360; + PyObject *__pyx_codeobj__361; + PyObject *__pyx_codeobj__362; + PyObject *__pyx_codeobj__363; + PyObject *__pyx_codeobj__364; + PyObject *__pyx_codeobj__365; + PyObject *__pyx_codeobj__366; + PyObject *__pyx_codeobj__367; + PyObject *__pyx_codeobj__369; + PyObject *__pyx_codeobj__370; + PyObject *__pyx_codeobj__371; + PyObject *__pyx_codeobj__372; + PyObject *__pyx_codeobj__373; + PyObject *__pyx_codeobj__374; + PyObject *__pyx_codeobj__375; + PyObject *__pyx_codeobj__376; + PyObject *__pyx_codeobj__378; + PyObject *__pyx_codeobj__379; + PyObject *__pyx_codeobj__380; + PyObject *__pyx_codeobj__381; + PyObject *__pyx_codeobj__382; + PyObject *__pyx_codeobj__383; + PyObject *__pyx_codeobj__384; + PyObject *__pyx_codeobj__385; + PyObject *__pyx_codeobj__386; + PyObject *__pyx_codeobj__387; + PyObject *__pyx_codeobj__388; + PyObject *__pyx_codeobj__389; + PyObject *__pyx_codeobj__390; + PyObject *__pyx_codeobj__391; + PyObject *__pyx_codeobj__392; + PyObject *__pyx_codeobj__393; + PyObject *__pyx_codeobj__395; + PyObject *__pyx_codeobj__396; + PyObject *__pyx_codeobj__397; + PyObject *__pyx_codeobj__399; + PyObject *__pyx_codeobj__401; + PyObject *__pyx_codeobj__403; + PyObject *__pyx_codeobj__404; + PyObject *__pyx_codeobj__405; + PyObject *__pyx_codeobj__406; + PyObject *__pyx_codeobj__407; + PyObject *__pyx_codeobj__408; + PyObject *__pyx_codeobj__409; + PyObject *__pyx_codeobj__410; + PyObject *__pyx_codeobj__411; + PyObject *__pyx_codeobj__413; + PyObject *__pyx_codeobj__414; + PyObject *__pyx_codeobj__415; + PyObject *__pyx_codeobj__416; + PyObject *__pyx_codeobj__417; + PyObject *__pyx_codeobj__419; + PyObject *__pyx_codeobj__420; + PyObject *__pyx_codeobj__421; + PyObject *__pyx_codeobj__422; + PyObject *__pyx_codeobj__423; + PyObject *__pyx_codeobj__424; + PyObject *__pyx_codeobj__425; + PyObject *__pyx_codeobj__426; + PyObject *__pyx_codeobj__427; + PyObject *__pyx_codeobj__428; + PyObject *__pyx_codeobj__429; + PyObject *__pyx_codeobj__430; + PyObject *__pyx_codeobj__431; + PyObject *__pyx_codeobj__432; + PyObject *__pyx_codeobj__433; + PyObject *__pyx_codeobj__434; + PyObject *__pyx_codeobj__435; + PyObject *__pyx_codeobj__437; + PyObject *__pyx_codeobj__438; + PyObject *__pyx_codeobj__439; + PyObject *__pyx_codeobj__443; + PyObject *__pyx_codeobj__444; + PyObject *__pyx_codeobj__445; + PyObject *__pyx_codeobj__446; + PyObject *__pyx_codeobj__447; + PyObject *__pyx_codeobj__448; + PyObject *__pyx_codeobj__449; + PyObject *__pyx_codeobj__450; + PyObject *__pyx_codeobj__451; + PyObject *__pyx_codeobj__452; + PyObject *__pyx_codeobj__453; + PyObject *__pyx_codeobj__454; + PyObject *__pyx_codeobj__455; + PyObject *__pyx_codeobj__456; + PyObject *__pyx_codeobj__457; + PyObject *__pyx_codeobj__458; + PyObject *__pyx_codeobj__459; + PyObject *__pyx_codeobj__460; + PyObject *__pyx_codeobj__461; + PyObject *__pyx_codeobj__462; + PyObject *__pyx_codeobj__463; + PyObject *__pyx_codeobj__464; + PyObject *__pyx_codeobj__465; + PyObject *__pyx_codeobj__466; + PyObject *__pyx_codeobj__467; + PyObject *__pyx_codeobj__468; + PyObject *__pyx_codeobj__469; + PyObject *__pyx_codeobj__470; + PyObject *__pyx_codeobj__472; + PyObject *__pyx_codeobj__473; + PyObject *__pyx_codeobj__474; + PyObject *__pyx_codeobj__476; + PyObject *__pyx_codeobj__477; + PyObject *__pyx_codeobj__478; + PyObject *__pyx_codeobj__480; + PyObject *__pyx_codeobj__482; + PyObject *__pyx_codeobj__484; + PyObject *__pyx_codeobj__485; + PyObject *__pyx_codeobj__486; + PyObject *__pyx_codeobj__487; + PyObject *__pyx_codeobj__489; + PyObject *__pyx_codeobj__490; + PyObject *__pyx_codeobj__491; + PyObject *__pyx_codeobj__492; + PyObject *__pyx_codeobj__493; + PyObject *__pyx_codeobj__494; + PyObject *__pyx_codeobj__495; + PyObject *__pyx_codeobj__496; + PyObject *__pyx_codeobj__497; + PyObject *__pyx_codeobj__498; + PyObject *__pyx_codeobj__499; + PyObject *__pyx_codeobj__500; + PyObject *__pyx_codeobj__501; + PyObject *__pyx_codeobj__502; + PyObject *__pyx_codeobj__503; + PyObject *__pyx_codeobj__504; + PyObject *__pyx_codeobj__505; + PyObject *__pyx_codeobj__506; + PyObject *__pyx_codeobj__507; + PyObject *__pyx_codeobj__508; + PyObject *__pyx_codeobj__510; + PyObject *__pyx_codeobj__511; + PyObject *__pyx_codeobj__512; + PyObject *__pyx_codeobj__514; + PyObject *__pyx_codeobj__516; + PyObject *__pyx_codeobj__517; + PyObject *__pyx_codeobj__518; + PyObject *__pyx_codeobj__519; + PyObject *__pyx_codeobj__520; + PyObject *__pyx_codeobj__522; + PyObject *__pyx_codeobj__523; + PyObject *__pyx_codeobj__524; + PyObject *__pyx_codeobj__525; + PyObject *__pyx_codeobj__526; + PyObject *__pyx_codeobj__527; + PyObject *__pyx_codeobj__529; + PyObject *__pyx_codeobj__531; + PyObject *__pyx_codeobj__532; + PyObject *__pyx_codeobj__533; + PyObject *__pyx_codeobj__534; + PyObject *__pyx_codeobj__535; + PyObject *__pyx_codeobj__536; + PyObject *__pyx_codeobj__537; + PyObject *__pyx_codeobj__538; + PyObject *__pyx_codeobj__539; + PyObject *__pyx_codeobj__540; + PyObject *__pyx_codeobj__542; + PyObject *__pyx_codeobj__543; + PyObject *__pyx_codeobj__544; + PyObject *__pyx_codeobj__545; + PyObject *__pyx_codeobj__546; + PyObject *__pyx_codeobj__547; + PyObject *__pyx_codeobj__548; + PyObject *__pyx_codeobj__549; + PyObject *__pyx_codeobj__550; + PyObject *__pyx_codeobj__552; + PyObject *__pyx_codeobj__553; + PyObject *__pyx_codeobj__554; + PyObject *__pyx_codeobj__555; + PyObject *__pyx_codeobj__557; + PyObject *__pyx_codeobj__559; + PyObject *__pyx_codeobj__561; + PyObject *__pyx_codeobj__563; + PyObject *__pyx_codeobj__564; + PyObject *__pyx_codeobj__565; + PyObject *__pyx_codeobj__566; + PyObject *__pyx_codeobj__568; + PyObject *__pyx_codeobj__569; + PyObject *__pyx_codeobj__570; + PyObject *__pyx_codeobj__571; + PyObject *__pyx_codeobj__573; + PyObject *__pyx_codeobj__574; + PyObject *__pyx_codeobj__575; + PyObject *__pyx_codeobj__576; + PyObject *__pyx_codeobj__577; + PyObject *__pyx_codeobj__578; + PyObject *__pyx_codeobj__579; + PyObject *__pyx_codeobj__580; + PyObject *__pyx_codeobj__581; + PyObject *__pyx_codeobj__582; + PyObject *__pyx_codeobj__583; + PyObject *__pyx_codeobj__584; + PyObject *__pyx_codeobj__585; + PyObject *__pyx_codeobj__586; + PyObject *__pyx_codeobj__587; + PyObject *__pyx_codeobj__588; + PyObject *__pyx_codeobj__589; + PyObject *__pyx_codeobj__590; + PyObject *__pyx_codeobj__591; + PyObject *__pyx_codeobj__592; + PyObject *__pyx_codeobj__593; + PyObject *__pyx_codeobj__594; + PyObject *__pyx_codeobj__595; + PyObject *__pyx_codeobj__597; + PyObject *__pyx_codeobj__598; + PyObject *__pyx_codeobj__599; + PyObject *__pyx_codeobj__600; + PyObject *__pyx_codeobj__601; + PyObject *__pyx_codeobj__603; + PyObject *__pyx_codeobj__605; + PyObject *__pyx_codeobj__606; + PyObject *__pyx_codeobj__608; + PyObject *__pyx_codeobj__610; + PyObject *__pyx_codeobj__612; + PyObject *__pyx_codeobj__613; + PyObject *__pyx_codeobj__615; + PyObject *__pyx_codeobj__616; + PyObject *__pyx_codeobj__617; + PyObject *__pyx_codeobj__618; + PyObject *__pyx_codeobj__619; + PyObject *__pyx_codeobj__620; + PyObject *__pyx_codeobj__621; + PyObject *__pyx_codeobj__622; + PyObject *__pyx_codeobj__623; + PyObject *__pyx_codeobj__624; + PyObject *__pyx_codeobj__625; + PyObject *__pyx_codeobj__626; + PyObject *__pyx_codeobj__627; + PyObject *__pyx_codeobj__628; + PyObject *__pyx_codeobj__629; + PyObject *__pyx_codeobj__630; + PyObject *__pyx_codeobj__631; + PyObject *__pyx_codeobj__632; + PyObject *__pyx_codeobj__633; + PyObject *__pyx_codeobj__634; + PyObject *__pyx_codeobj__635; + PyObject *__pyx_codeobj__637; + PyObject *__pyx_codeobj__638; + PyObject *__pyx_codeobj__639; + PyObject *__pyx_codeobj__640; + PyObject *__pyx_codeobj__641; + PyObject *__pyx_codeobj__642; + PyObject *__pyx_codeobj__643; + PyObject *__pyx_codeobj__645; + PyObject *__pyx_codeobj__646; + PyObject *__pyx_codeobj__647; + PyObject *__pyx_codeobj__648; + PyObject *__pyx_codeobj__649; + PyObject *__pyx_codeobj__650; + PyObject *__pyx_codeobj__652; + PyObject *__pyx_codeobj__655; + PyObject *__pyx_codeobj__657; + PyObject *__pyx_codeobj__658; + PyObject *__pyx_codeobj__659; + PyObject *__pyx_codeobj__661; + PyObject *__pyx_codeobj__662; + PyObject *__pyx_codeobj__664; + PyObject *__pyx_codeobj__667; + PyObject *__pyx_codeobj__669; + PyObject *__pyx_codeobj__671; + PyObject *__pyx_codeobj__672; + PyObject *__pyx_codeobj__673; + PyObject *__pyx_codeobj__675; + PyObject *__pyx_codeobj__677; + PyObject *__pyx_codeobj__678; + PyObject *__pyx_codeobj__679; + PyObject *__pyx_codeobj__681; + PyObject *__pyx_codeobj__683; + PyObject *__pyx_codeobj__686; + PyObject *__pyx_codeobj__689; + PyObject *__pyx_codeobj__691; + PyObject *__pyx_codeobj__693; + PyObject *__pyx_codeobj__695; + PyObject *__pyx_codeobj__697; + PyObject *__pyx_codeobj__699; + PyObject *__pyx_codeobj__700; + PyObject *__pyx_codeobj__701; + PyObject *__pyx_codeobj__703; + PyObject *__pyx_codeobj__705; + PyObject *__pyx_codeobj__706; + PyObject *__pyx_codeobj__707; + PyObject *__pyx_codeobj__709; + PyObject *__pyx_codeobj__711; + PyObject *__pyx_codeobj__713; + PyObject *__pyx_codeobj__715; + PyObject *__pyx_codeobj__717; + PyObject *__pyx_codeobj__718; + PyObject *__pyx_codeobj__719; + PyObject *__pyx_codeobj__721; + PyObject *__pyx_codeobj__723; + PyObject *__pyx_codeobj__724; + PyObject *__pyx_codeobj__725; + PyObject *__pyx_codeobj__726; + PyObject *__pyx_codeobj__727; + PyObject *__pyx_codeobj__728; + PyObject *__pyx_codeobj__729; + PyObject *__pyx_codeobj__731; + PyObject *__pyx_codeobj__732; + PyObject *__pyx_codeobj__733; + PyObject *__pyx_codeobj__735; + PyObject *__pyx_codeobj__736; + PyObject *__pyx_codeobj__738; + PyObject *__pyx_codeobj__740; + PyObject *__pyx_codeobj__741; + PyObject *__pyx_codeobj__742; + PyObject *__pyx_codeobj__744; + PyObject *__pyx_codeobj__746; + PyObject *__pyx_codeobj__748; + PyObject *__pyx_codeobj__749; + PyObject *__pyx_codeobj__751; + PyObject *__pyx_codeobj__754; + PyObject *__pyx_codeobj__755; + PyObject *__pyx_codeobj__756; + PyObject *__pyx_codeobj__757; + PyObject *__pyx_codeobj__758; + PyObject *__pyx_codeobj__759; + PyObject *__pyx_codeobj__761; + PyObject *__pyx_codeobj__762; + PyObject *__pyx_codeobj__763; + PyObject *__pyx_codeobj__764; + PyObject *__pyx_codeobj__766; + PyObject *__pyx_codeobj__768; + PyObject *__pyx_codeobj__769; + PyObject *__pyx_codeobj__771; + PyObject *__pyx_codeobj__773; + PyObject *__pyx_codeobj__774; + PyObject *__pyx_codeobj__776; + PyObject *__pyx_codeobj__777; + PyObject *__pyx_codeobj__778; + PyObject *__pyx_codeobj__779; + PyObject *__pyx_codeobj__781; + PyObject *__pyx_codeobj__784; + PyObject *__pyx_codeobj__786; + PyObject *__pyx_codeobj__788; + PyObject *__pyx_codeobj__790; + PyObject *__pyx_codeobj__792; + PyObject *__pyx_codeobj__795; + PyObject *__pyx_codeobj__797; + PyObject *__pyx_codeobj__799; + PyObject *__pyx_codeobj__802; + PyObject *__pyx_codeobj__804; + PyObject *__pyx_codeobj__806; + PyObject *__pyx_codeobj__807; + PyObject *__pyx_codeobj__809; + PyObject *__pyx_codeobj__811; + PyObject *__pyx_codeobj__813; + PyObject *__pyx_codeobj__815; + PyObject *__pyx_codeobj__817; + PyObject *__pyx_codeobj__819; + PyObject *__pyx_codeobj__822; + PyObject *__pyx_codeobj__824; + PyObject *__pyx_codeobj__827; + PyObject *__pyx_codeobj__830; + PyObject *__pyx_codeobj__833; + PyObject *__pyx_codeobj__836; + PyObject *__pyx_codeobj__838; + PyObject *__pyx_codeobj__840; + PyObject *__pyx_codeobj__841; + PyObject *__pyx_codeobj__842; + PyObject *__pyx_codeobj__843; + PyObject *__pyx_codeobj__845; + PyObject *__pyx_codeobj__847; + PyObject *__pyx_codeobj__849; + PyObject *__pyx_codeobj__851; + PyObject *__pyx_codeobj__853; + PyObject *__pyx_codeobj__855; + PyObject *__pyx_codeobj__857; + PyObject *__pyx_codeobj__858; + PyObject *__pyx_codeobj__860; + PyObject *__pyx_codeobj__861; + PyObject *__pyx_codeobj__862; + PyObject *__pyx_codeobj__864; + PyObject *__pyx_codeobj__866; + PyObject *__pyx_codeobj__868; + PyObject *__pyx_codeobj__869; + PyObject *__pyx_codeobj__870; + PyObject *__pyx_codeobj__872; + PyObject *__pyx_codeobj__874; + PyObject *__pyx_codeobj__876; + PyObject *__pyx_codeobj__878; + PyObject *__pyx_codeobj__880; + PyObject *__pyx_codeobj__882; + PyObject *__pyx_codeobj__884; + PyObject *__pyx_codeobj__886; + PyObject *__pyx_codeobj__888; + PyObject *__pyx_codeobj__889; + PyObject *__pyx_codeobj__890; + PyObject *__pyx_codeobj__891; + PyObject *__pyx_codeobj__893; + PyObject *__pyx_codeobj__895; + PyObject *__pyx_codeobj__897; + PyObject *__pyx_codeobj__898; + PyObject *__pyx_codeobj__899; + PyObject *__pyx_codeobj__901; + PyObject *__pyx_codeobj__903; + PyObject *__pyx_codeobj__904; + PyObject *__pyx_codeobj__905; + PyObject *__pyx_codeobj__906; + PyObject *__pyx_codeobj__908; + PyObject *__pyx_codeobj__910; + PyObject *__pyx_codeobj__912; + PyObject *__pyx_codeobj__914; + PyObject *__pyx_codeobj__916; + PyObject *__pyx_codeobj__918; + PyObject *__pyx_codeobj__920; + PyObject *__pyx_codeobj__922; + PyObject *__pyx_codeobj__924; + PyObject *__pyx_codeobj__926; + PyObject *__pyx_codeobj__928; + PyObject *__pyx_codeobj__931; + PyObject *__pyx_codeobj__933; + PyObject *__pyx_codeobj__935; + PyObject *__pyx_codeobj__937; + PyObject *__pyx_codeobj__939; + PyObject *__pyx_codeobj__942; + PyObject *__pyx_codeobj__944; + PyObject *__pyx_codeobj__947; + PyObject *__pyx_codeobj__949; + PyObject *__pyx_codeobj__952; + PyObject *__pyx_codeobj__954; + PyObject *__pyx_codeobj__956; + PyObject *__pyx_codeobj__958; + PyObject *__pyx_codeobj__961; + PyObject *__pyx_codeobj__963; + PyObject *__pyx_codeobj__965; + PyObject *__pyx_codeobj__967; + PyObject *__pyx_codeobj__970; + PyObject *__pyx_codeobj__972; + PyObject *__pyx_codeobj__974; + PyObject *__pyx_codeobj__976; + PyObject *__pyx_codeobj__978; + PyObject *__pyx_codeobj__980; + PyObject *__pyx_codeobj__982; + PyObject *__pyx_codeobj__984; + PyObject *__pyx_codeobj__985; + PyObject *__pyx_codeobj__986; + PyObject *__pyx_codeobj__988; + PyObject *__pyx_codeobj__990; + PyObject *__pyx_codeobj__991; + PyObject *__pyx_codeobj__992; + PyObject *__pyx_codeobj__993; + PyObject *__pyx_codeobj__995; + PyObject *__pyx_codeobj__997; + PyObject *__pyx_codeobj__998; + PyObject *__pyx_codeobj__1000; + PyObject *__pyx_codeobj__1002; + PyObject *__pyx_codeobj__1003; + PyObject *__pyx_codeobj__1004; + PyObject *__pyx_codeobj__1005; + PyObject *__pyx_codeobj__1007; + PyObject *__pyx_codeobj__1008; + PyObject *__pyx_codeobj__1009; + PyObject *__pyx_codeobj__1010; + PyObject *__pyx_codeobj__1011; + PyObject *__pyx_codeobj__1013; + PyObject *__pyx_codeobj__1014; + PyObject *__pyx_codeobj__1015; + PyObject *__pyx_codeobj__1016; + PyObject *__pyx_codeobj__1017; + PyObject *__pyx_codeobj__1019; + PyObject *__pyx_codeobj__1020; + PyObject *__pyx_codeobj__1021; + PyObject *__pyx_codeobj__1023; + PyObject *__pyx_codeobj__1026; + PyObject *__pyx_codeobj__1028; + PyObject *__pyx_codeobj__1029; + PyObject *__pyx_codeobj__1031; + PyObject *__pyx_codeobj__1033; + PyObject *__pyx_codeobj__1036; + PyObject *__pyx_codeobj__1038; + PyObject *__pyx_codeobj__1041; + PyObject *__pyx_codeobj__1042; + PyObject *__pyx_codeobj__1043; + PyObject *__pyx_codeobj__1045; + PyObject *__pyx_codeobj__1047; + PyObject *__pyx_codeobj__1049; + PyObject *__pyx_codeobj__1052; + PyObject *__pyx_codeobj__1055; + PyObject *__pyx_codeobj__1056; + PyObject *__pyx_codeobj__1057; + PyObject *__pyx_codeobj__1058; + PyObject *__pyx_codeobj__1059; + PyObject *__pyx_codeobj__1060; + PyObject *__pyx_codeobj__1062; + PyObject *__pyx_codeobj__1063; + PyObject *__pyx_codeobj__1065; + PyObject *__pyx_codeobj__1067; + PyObject *__pyx_codeobj__1068; + PyObject *__pyx_codeobj__1070; + PyObject *__pyx_codeobj__1072; + PyObject *__pyx_codeobj__1073; + PyObject *__pyx_codeobj__1074; + PyObject *__pyx_codeobj__1076; + PyObject *__pyx_codeobj__1077; + PyObject *__pyx_codeobj__1078; + PyObject *__pyx_codeobj__1079; + PyObject *__pyx_codeobj__1081; + PyObject *__pyx_codeobj__1082; + PyObject *__pyx_codeobj__1083; + PyObject *__pyx_codeobj__1084; + PyObject *__pyx_codeobj__1085; + PyObject *__pyx_codeobj__1087; + PyObject *__pyx_codeobj__1089; + PyObject *__pyx_codeobj__1090; + PyObject *__pyx_codeobj__1092; + PyObject *__pyx_codeobj__1093; + PyObject *__pyx_codeobj__1095; + PyObject *__pyx_codeobj__1096; + PyObject *__pyx_codeobj__1097; + PyObject *__pyx_codeobj__1099; + PyObject *__pyx_codeobj__1101; + PyObject *__pyx_codeobj__1103; + PyObject *__pyx_codeobj__1105; + PyObject *__pyx_codeobj__1107; + PyObject *__pyx_codeobj__1109; + PyObject *__pyx_codeobj__1110; + PyObject *__pyx_codeobj__1111; + PyObject *__pyx_codeobj__1112; + PyObject *__pyx_codeobj__1113; + PyObject *__pyx_codeobj__1115; + PyObject *__pyx_codeobj__1117; + PyObject *__pyx_codeobj__1119; + PyObject *__pyx_codeobj__1121; + PyObject *__pyx_codeobj__1123; + PyObject *__pyx_codeobj__1125; + PyObject *__pyx_codeobj__1127; + PyObject *__pyx_codeobj__1129; + PyObject *__pyx_codeobj__1130; + PyObject *__pyx_codeobj__1132; + PyObject *__pyx_codeobj__1134; + PyObject *__pyx_codeobj__1135; + PyObject *__pyx_codeobj__1136; + PyObject *__pyx_codeobj__1138; + PyObject *__pyx_codeobj__1139; + PyObject *__pyx_codeobj__1140; + PyObject *__pyx_codeobj__1142; + PyObject *__pyx_codeobj__1145; + PyObject *__pyx_codeobj__1146; + PyObject *__pyx_codeobj__1147; + PyObject *__pyx_codeobj__1148; + PyObject *__pyx_codeobj__1149; + PyObject *__pyx_codeobj__1150; + PyObject *__pyx_codeobj__1152; + PyObject *__pyx_codeobj__1153; + PyObject *__pyx_codeobj__1154; + PyObject *__pyx_codeobj__1155; + PyObject *__pyx_codeobj__1156; + PyObject *__pyx_codeobj__1157; + PyObject *__pyx_codeobj__1158; + PyObject *__pyx_codeobj__1159; + PyObject *__pyx_codeobj__1160; + PyObject *__pyx_codeobj__1161; + PyObject *__pyx_codeobj__1162; + PyObject *__pyx_codeobj__1163; + PyObject *__pyx_codeobj__1164; + PyObject *__pyx_codeobj__1165; + PyObject *__pyx_codeobj__1166; + PyObject *__pyx_codeobj__1167; + PyObject *__pyx_codeobj__1168; + PyObject *__pyx_codeobj__1169; + PyObject *__pyx_codeobj__1170; + PyObject *__pyx_codeobj__1171; + PyObject *__pyx_codeobj__1172; + PyObject *__pyx_codeobj__1173; + PyObject *__pyx_codeobj__1174; + PyObject *__pyx_codeobj__1175; + PyObject *__pyx_codeobj__1176; + PyObject *__pyx_codeobj__1177; + PyObject *__pyx_codeobj__1178; + PyObject *__pyx_codeobj__1179; + PyObject *__pyx_codeobj__1180; + PyObject *__pyx_codeobj__1181; + PyObject *__pyx_codeobj__1182; + PyObject *__pyx_codeobj__1183; + PyObject *__pyx_codeobj__1184; + PyObject *__pyx_codeobj__1185; + PyObject *__pyx_codeobj__1186; + PyObject *__pyx_codeobj__1187; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4bool_bool); + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_7complex_complex); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Expr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Expr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Event); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Event); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Column); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Column); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Row); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Row); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_NLRow); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_NLRow); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Solution); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Solution); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_DomainChanges); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_DomainChanges); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_BoundChange); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_BoundChange); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Node); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Node); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Variable); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Variable); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Constraint); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Constraint); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Model); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Model); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_ExprCons); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_ExprCons); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_GenExpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_GenExpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_SumExpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_SumExpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_ProdExpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_ProdExpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_VarExpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_VarExpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PowExpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PowExpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_UnaryExpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_UnaryExpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Constant); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Constant); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_LP); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_LP); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Benders); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Benders); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Benderscut); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Benderscut); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Branchrule); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Branchrule); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Conshdlr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Conshdlr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Cutsel); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Cutsel); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Eventhdlr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Eventhdlr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Heur); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Heur); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Presol); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Presol); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Pricer); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Pricer); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Prop); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Prop); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Sepa); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Sepa); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Reader); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Reader); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Relax); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Relax); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_Nodesel); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_Nodesel); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem__); + Py_CLEAR(clear_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_AFTERLPLOOP); + Py_CLEAR(clear_module_state->__pyx_n_s_AFTERLPNODE); + Py_CLEAR(clear_module_state->__pyx_n_s_AFTERLPPLUNGE); + Py_CLEAR(clear_module_state->__pyx_n_s_AFTERPROPLOOP); + Py_CLEAR(clear_module_state->__pyx_n_s_AFTERPSEUDONODE); + Py_CLEAR(clear_module_state->__pyx_n_s_AFTERPSEUDOPLUNGE); + Py_CLEAR(clear_module_state->__pyx_n_s_AGGRESSIVE); + Py_CLEAR(clear_module_state->__pyx_n_u_ANDcons); + Py_CLEAR(clear_module_state->__pyx_n_s_AUTO); + Py_CLEAR(clear_module_state->__pyx_n_s_AssertionError); + Py_CLEAR(clear_module_state->__pyx_n_u_B); + Py_CLEAR(clear_module_state->__pyx_n_s_BEFORELP); + Py_CLEAR(clear_module_state->__pyx_n_s_BEFORENODE); + Py_CLEAR(clear_module_state->__pyx_n_s_BEFOREPRESOL); + Py_CLEAR(clear_module_state->__pyx_n_s_BENCHMARK); + Py_CLEAR(clear_module_state->__pyx_n_s_BESTSOLFOUND); + Py_CLEAR(clear_module_state->__pyx_n_s_BESTSOLLIMIT); + Py_CLEAR(clear_module_state->__pyx_n_u_BINARY); + Py_CLEAR(clear_module_state->__pyx_n_s_BOUNDCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_BOUNDRELAXED); + Py_CLEAR(clear_module_state->__pyx_n_s_BOUNDTIGHTENED); + Py_CLEAR(clear_module_state->__pyx_n_s_BRANCHED); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_benderscreatesub); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersexitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersfreesub); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersgetvar); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersinitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_bendersinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_benderspostsolve); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_benderspresubsolve); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_benderssolvesub); + Py_CLEAR(clear_module_state->__pyx_n_s_Benders_benderssolvesubconvex); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut_benderscutexec); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut_benderscutexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut_benderscutexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut_benderscutfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut_benderscutinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Benderscut_benderscutinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_BoundChange); + Py_CLEAR(clear_module_state->__pyx_n_s_BoundChange___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_BoundChange___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_BoundChange_getBoundchgtype); + Py_CLEAR(clear_module_state->__pyx_n_s_BoundChange_getBoundtype); + Py_CLEAR(clear_module_state->__pyx_n_s_BoundChange_getNewBound); + Py_CLEAR(clear_module_state->__pyx_n_s_BoundChange_getVar); + Py_CLEAR(clear_module_state->__pyx_n_s_BoundChange_isRedundant); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule_branchexecext); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule_branchexeclp); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule_branchexecps); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule_branchexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule_branchexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule_branchfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule_branchinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Branchrule_branchinitsol); + Py_CLEAR(clear_module_state->__pyx_n_u_C); + Py_CLEAR(clear_module_state->__pyx_n_s_CHECK); + Py_CLEAR(clear_module_state->__pyx_n_s_CHILD); + Py_CLEAR(clear_module_state->__pyx_n_s_CONS); + Py_CLEAR(clear_module_state->__pyx_n_s_CONSADDED); + Py_CLEAR(clear_module_state->__pyx_n_s_CONSCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_CONST); + Py_CLEAR(clear_module_state->__pyx_n_u_CONTINUOUS); + Py_CLEAR(clear_module_state->__pyx_n_s_COUNTER); + Py_CLEAR(clear_module_state->__pyx_n_s_CPSOLVER); + Py_CLEAR(clear_module_state->__pyx_n_s_CUTOFF); + Py_CLEAR(clear_module_state->__pyx_kp_u_Can_only_support_constraints_wit); + Py_CLEAR(clear_module_state->__pyx_kp_u_Can_t_evaluate_constraints_as_bo); + Py_CLEAR(clear_module_state->__pyx_kp_u_Cannot_set_value_to_a_freed_solu); + Py_CLEAR(clear_module_state->__pyx_n_u_CardinalityCons); + Py_CLEAR(clear_module_state->__pyx_n_s_Column); + Py_CLEAR(clear_module_state->__pyx_n_s_Column___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Column___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Column_getBasisStatus); + Py_CLEAR(clear_module_state->__pyx_n_s_Column_getLPPos); + Py_CLEAR(clear_module_state->__pyx_n_s_Column_getLb); + Py_CLEAR(clear_module_state->__pyx_n_s_Column_getObjCoeff); + Py_CLEAR(clear_module_state->__pyx_n_s_Column_getPrimsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Column_getUb); + Py_CLEAR(clear_module_state->__pyx_n_s_Column_getVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Column_isIntegral); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consactive); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_conscheck); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_conscopy); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consdeactive); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consdelete); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consdelvars); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consdisable); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consenable); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consenfolp); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consenfops); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consenforelax); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consexitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consgetdivebdchgs); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consgetnvars); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consgetpermsymgraph); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consgetsignedpermsymgra); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consgetvars); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consinitlp); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consinitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_conslock); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consparse); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_conspresol); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consprint); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consprop); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_consresprop); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_conssepalp); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_conssepasol); + Py_CLEAR(clear_module_state->__pyx_n_s_Conshdlr_constrans); + Py_CLEAR(clear_module_state->__pyx_n_s_Constant); + Py_CLEAR(clear_module_state->__pyx_n_s_Constant___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Constant___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_u_Constant_offsets_in_objective_ar); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_getConshdlrName); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isActive); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isChecked); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isDynamic); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isEnforced); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isInitial); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isModifiable); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isOriginal); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isPropagated); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isRemovable); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isSeparated); + Py_CLEAR(clear_module_state->__pyx_n_s_Constraint_isStickingAtNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel_cutselexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel_cutselexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel_cutselfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel_cutselinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel_cutselinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Cutsel_cutselselect); + Py_CLEAR(clear_module_state->__pyx_n_s_DEADEND); + Py_CLEAR(clear_module_state->__pyx_n_s_DEFAULT); + Py_CLEAR(clear_module_state->__pyx_n_s_DELAYED); + Py_CLEAR(clear_module_state->__pyx_n_s_DIDNOTFIND); + Py_CLEAR(clear_module_state->__pyx_n_s_DIDNOTRUN); + Py_CLEAR(clear_module_state->__pyx_n_s_DISABLED); + Py_CLEAR(clear_module_state->__pyx_n_s_DOMCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_DOWNWARDS); + Py_CLEAR(clear_module_state->__pyx_n_s_DUALLIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_DURINGLPLOOP); + Py_CLEAR(clear_module_state->__pyx_n_s_DURINGPRESOLLOOP); + Py_CLEAR(clear_module_state->__pyx_n_s_DURINGPRICINGLOOP); + Py_CLEAR(clear_module_state->__pyx_n_s_DomainChanges); + Py_CLEAR(clear_module_state->__pyx_n_s_DomainChanges___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_DomainChanges___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_DomainChanges_getBoundchgs); + Py_CLEAR(clear_module_state->__pyx_n_s_EASYCIP); + Py_CLEAR(clear_module_state->__pyx_n_s_ERROR); + Py_CLEAR(clear_module_state->__pyx_n_s_EXHAUSTIVE); + Py_CLEAR(clear_module_state->__pyx_n_s_EXITPRESOLVE); + Py_CLEAR(clear_module_state->__pyx_n_s_EXITSOLVE); + Py_CLEAR(clear_module_state->__pyx_n_s_Event); + Py_CLEAR(clear_module_state->__pyx_n_s_EventNames); + Py_CLEAR(clear_module_state->__pyx_n_s_Event___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Event___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Event__getEventNames); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_getName); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_getNewBound); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_getNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_getOldBound); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_getRow); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_getType); + Py_CLEAR(clear_module_state->__pyx_n_s_Event_getVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr_eventcopy); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr_eventdelete); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr_eventexec); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr_eventexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr_eventexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr_eventfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr_eventinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Eventhdlr_eventinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Expr); + Py_CLEAR(clear_module_state->__pyx_kp_u_ExprCons); + Py_CLEAR(clear_module_state->__pyx_n_s_ExprCons_2); + Py_CLEAR(clear_module_state->__pyx_n_s_ExprCons___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ExprCons___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_kp_u_ExprCons_already_has_lower_bound); + Py_CLEAR(clear_module_state->__pyx_kp_u_ExprCons_already_has_upper_bound); + Py_CLEAR(clear_module_state->__pyx_n_s_ExprCons_normalize); + Py_CLEAR(clear_module_state->__pyx_n_s_Expr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Expr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Expr_degree); + Py_CLEAR(clear_module_state->__pyx_n_s_Expr_normalize); + Py_CLEAR(clear_module_state->__pyx_kp_u_Expr_s); + Py_CLEAR(clear_module_state->__pyx_n_s_FAST); + Py_CLEAR(clear_module_state->__pyx_n_s_FEASIBILITY); + Py_CLEAR(clear_module_state->__pyx_n_s_FEASIBLE); + Py_CLEAR(clear_module_state->__pyx_n_s_FIRSTLPSOLVED); + Py_CLEAR(clear_module_state->__pyx_n_s_FIXED); + Py_CLEAR(clear_module_state->__pyx_n_s_FOCUSNODE); + Py_CLEAR(clear_module_state->__pyx_n_s_FORK); + Py_CLEAR(clear_module_state->__pyx_n_s_FOUNDSOL); + Py_CLEAR(clear_module_state->__pyx_n_s_FREE); + Py_CLEAR(clear_module_state->__pyx_n_s_FREETRANS); + Py_CLEAR(clear_module_state->__pyx_n_s_GAPLIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_GBDCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_GHOLEADDED); + Py_CLEAR(clear_module_state->__pyx_n_s_GHOLECHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_GHOLEREMOVED); + Py_CLEAR(clear_module_state->__pyx_n_s_GLBCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_GUBCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_GenExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_GenExpr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_GenExpr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_GenExpr_degree); + Py_CLEAR(clear_module_state->__pyx_n_s_GenExpr_getOp); + Py_CLEAR(clear_module_state->__pyx_kp_u_Given_constraint_list_is_not_ite); + Py_CLEAR(clear_module_state->__pyx_kp_u_Given_constraint_list_is_not_ite_2); + Py_CLEAR(clear_module_state->__pyx_n_s_HARDLP); + Py_CLEAR(clear_module_state->__pyx_n_s_HOLECHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur_heurexec); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur_heurexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur_heurexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur_heurfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur_heurinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Heur_heurinitsol); + Py_CLEAR(clear_module_state->__pyx_n_u_I); + Py_CLEAR(clear_module_state->__pyx_n_s_IMPLADDED); + Py_CLEAR(clear_module_state->__pyx_n_u_IMPLINT); + Py_CLEAR(clear_module_state->__pyx_n_s_INFEASIBLE); + Py_CLEAR(clear_module_state->__pyx_n_s_INFORUNBD); + Py_CLEAR(clear_module_state->__pyx_n_s_INIT); + Py_CLEAR(clear_module_state->__pyx_n_s_INITPRESOLVE); + Py_CLEAR(clear_module_state->__pyx_n_s_INITSOLVE); + Py_CLEAR(clear_module_state->__pyx_n_u_INTEGER); + Py_CLEAR(clear_module_state->__pyx_n_s_IOError); + Py_CLEAR(clear_module_state->__pyx_n_s_ITERLIMIT); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_7); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_8); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_9); + Py_CLEAR(clear_module_state->__pyx_n_u_IndicatorCons); + Py_CLEAR(clear_module_state->__pyx_n_s_Iterable); + Py_CLEAR(clear_module_state->__pyx_n_s_JUNCTION); + Py_CLEAR(clear_module_state->__pyx_n_s_KeyError); + Py_CLEAR(clear_module_state->__pyx_n_s_LBCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_LBRELAXED); + Py_CLEAR(clear_module_state->__pyx_n_s_LBTIGHTENED); + Py_CLEAR(clear_module_state->__pyx_n_s_LC_NUMERIC); + Py_CLEAR(clear_module_state->__pyx_n_s_LEAF); + Py_CLEAR(clear_module_state->__pyx_n_s_LHOLEADDED); + Py_CLEAR(clear_module_state->__pyx_n_s_LHOLECHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_LHOLEREMOVED); + Py_CLEAR(clear_module_state->__pyx_n_s_LP); + Py_CLEAR(clear_module_state->__pyx_n_u_LP); + Py_CLEAR(clear_module_state->__pyx_n_s_LPEVENT); + Py_CLEAR(clear_module_state->__pyx_n_s_LPSOLVED); + Py_CLEAR(clear_module_state->__pyx_n_s_LP___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_LP___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_addCol); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_addCols); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_addRow); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_addRows); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_chgBound); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_chgCoef); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_chgObj); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_chgSide); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_clear); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_delCols); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_delRows); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getBasisInds); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getBounds); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getDual); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getDualRay); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getNIterations); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getPrimal); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getPrimalRay); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getRedcost); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_getSides); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_infinity); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_isDualFeasible); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_isInfinity); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_isPrimalFeasible); + Py_CLEAR(clear_module_state->__pyx_kp_u_LP_lp); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_ncols); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_nrows); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_readLP); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_solve); + Py_CLEAR(clear_module_state->__pyx_n_s_LP_writeLP); + Py_CLEAR(clear_module_state->__pyx_n_s_LookupError); + Py_CLEAR(clear_module_state->__pyx_n_u_M); + Py_CLEAR(clear_module_state->__pyx_n_s_MAJOR); + Py_CLEAR(clear_module_state->__pyx_n_s_MEDIUM); + Py_CLEAR(clear_module_state->__pyx_n_s_MEMLIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_MINOR); + Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); + Py_CLEAR(clear_module_state->__pyx_n_s_Model); + Py_CLEAR(clear_module_state->__pyx_n_s_Model___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Model___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Model__createConsGenNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model__createConsLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model__createConsNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model__createConsQuadratic); + Py_CLEAR(clear_module_state->__pyx_n_s_Model__getStageNames); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_activateBenders); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addBendersSubproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addCoefLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addCons); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsAnd); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsCardinality); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsCoeff); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsDisjunction); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsElemDisjunction); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsIndicator); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsOr); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsSOS1); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsSOS2); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConsXor); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addConss); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addCut); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addExprNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addObjoffset); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addPoolCut); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addPyCons); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addRowDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addVarLocks); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addVarSOS1); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addVarSOS2); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_addVarToRow); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_appendVarSOS1); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_appendVarSOS2); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_applyCutsProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_backtrackProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_branchVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_branchVarVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_cacheRowExtensions); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_calcChildEstimate); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_calcNodeselPriority); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_catchEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_catchRowEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_catchVarEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_checkBendersSubproblemOpti); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_checkQuadraticNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_checkSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgCoefLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgLhs); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgReoptObjective); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgRhs); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgRowLhsDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgRowRhsDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarBranchPriority); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarLb); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarLbDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarLbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarLbNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarLbProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarObjDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarObjProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarType); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarUb); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarUbDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarUbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarUbNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_chgVarUbProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_computeBestSolSubproblems); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_constructLP); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_count); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createChild); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createCons); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createConsFromExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createEmptyRowSepa); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createEmptyRowUnspec); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createOrigSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createPartialSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createProbBasic); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_createSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_delCoefLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_delCons); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_delConsLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_delVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_disablePropagation); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_dropEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_dropRowEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_dropVarEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_enableReoptimization); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_endDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_endProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_epsilon); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_feasFrac); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_feastol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_fixVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_fixVarProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_flushRowExtensions); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_frac); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_freeBendersSubproblems); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_freeProb); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_freeReoptSolve); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_freeSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_freeTransform); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_from_ptr); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getActivity); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBendersAuxiliaryVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBendersSubproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBendersVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBestChild); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBestLeaf); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBestNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBestSibling); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBestSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getBestboundNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getCondition); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getConsNVars); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getConsVars); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getConss); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getCurrentNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getCutEfficacy); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getCutLPSolCutoffDistance); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getDepth); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getDualMultiplier); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getDualSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getDualbound); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getDualboundRoot); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getDualfarkasLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getDualsolLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getGap); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLPBInvARow); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLPBInvRow); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLPBasisInd); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLPBranchCands); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLPColsData); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLPObjVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLPRowsData); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLPSolstat); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLhs); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getLocalEstimate); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNBestSolsFound); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNBinVars); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNChildren); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNConss); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNCountedSols); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNCuts); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNCutsApplied); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNFeasibleLeaves); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNInfeasibleLeaves); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNIntVars); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNLPCols); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNLPIterations); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNLPRows); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNLPs); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNLeaves); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNLimSolsFound); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNNlRows); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNNodes); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNReaders); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNSepaRounds); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNSiblings); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNSols); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNSolsFound); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNTotalNodes); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNVars); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNlRowActivityBounds); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNlRowSolActivity); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNlRowSolFeasibility); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getNlRows); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getObjVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getObjective); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getObjectiveSense); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getObjlimit); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getObjoffset); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getOpenNodes); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getParams); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getPresolvingTime); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getPrimalRay); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getPrimalRayVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getPrimalbound); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getProbName); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getProbingDepth); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getPseudoBranchCands); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getReadingTime); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getRhs); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getRowActivity); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getRowDualSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getRowLPActivity); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getRowLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getRowNumIntCols); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getRowObjParallelism); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getRowParallelism); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getSlack); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getSlackVarIndicator); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getSolObjVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getSolTime); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getSols); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getSolvingTime); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getStage); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getStageName); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getStatus); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getTermsQuadratic); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getTotalTime); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getTransformedCons); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getTransformedVar); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getTreesizeEstimation); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getValsLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getVarDict); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getVarLbDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getVarRedcost); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getVarUbDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_getVars); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_hasPrimalRay); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_hideOutput); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_inProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_inRepropagation); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeBenders); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeBendersDefaultCuts); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeBenderscut); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeBranchrule); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeConshdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeCutsel); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeDefaultPlugins); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeEventhdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeHeur); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeNodesel); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includePresol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includePricer); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeProp); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeReader); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeRelax); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_includeSepa); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_infinity); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_initBendersDefault); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_interruptSolve); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isCutEfficacious); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isEQ); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isFeasEQ); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isFeasIntegral); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isFeasNegative); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isFeasZero); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isGE); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isGT); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isInfinity); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isLE); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isLPSolBasic); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isLT); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isNLPConstructed); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isObjChangedProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_isZero); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_lpiGetIterations); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_newProbingNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_optimize); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_presolve); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_printBestSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_printCons); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_printExternalCodeVersions); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_printNlRow); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_printRow); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_printSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_printStatistics); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_printVersion); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_propagateProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_readParams); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_readProblem); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_readSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_readSolFile); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_redirectOutput); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_relax); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_releaseRow); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_repropagateNode); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_resetParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_resetParams); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_restartSolve); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_separateSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setBendersSubproblemIsConv); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setBoolParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setCharParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setCheck); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setEmphasis); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setEnforced); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setHeuristics); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setInitial); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setIntParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setLogfile); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setLongintParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setMaximize); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setMinimize); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setObjIntegral); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setObjective); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setObjlimit); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setParams); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setParamsCountsols); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setPresolve); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setProbName); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setRealParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setRelaxSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setRemovable); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setSeparating); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setStringParam); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_setupBendersSubproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_solveBendersSubproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_solveConcurrent); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_solveDiveLP); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_solveProbingLP); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_startDive); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_startProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_tightenVarLb); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_tightenVarLbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_tightenVarUb); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_tightenVarUbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_to_ptr); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_trySol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_updateBendersLowerbounds); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_updateNodeLowerbound); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_version); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeBestSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeBestTransSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeLP); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeName); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeParams); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeProblem); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeStatistics); + Py_CLEAR(clear_module_state->__pyx_n_s_Model_writeTransSol); + Py_CLEAR(clear_module_state->__pyx_n_s_NEWROUND); + Py_CLEAR(clear_module_state->__pyx_n_s_NLRow); + Py_CLEAR(clear_module_state->__pyx_n_s_NLRow___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_NLRow___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_NLRow_getConstant); + Py_CLEAR(clear_module_state->__pyx_n_s_NLRow_getDualsol); + Py_CLEAR(clear_module_state->__pyx_n_s_NLRow_getLhs); + Py_CLEAR(clear_module_state->__pyx_n_s_NLRow_getLinearTerms); + Py_CLEAR(clear_module_state->__pyx_n_s_NLRow_getRhs); + Py_CLEAR(clear_module_state->__pyx_n_s_NODEBRANCHED); + Py_CLEAR(clear_module_state->__pyx_n_s_NODEDELETE); + Py_CLEAR(clear_module_state->__pyx_n_s_NODEEVENT); + Py_CLEAR(clear_module_state->__pyx_n_s_NODEFEASIBLE); + Py_CLEAR(clear_module_state->__pyx_n_s_NODEFOCUSED); + Py_CLEAR(clear_module_state->__pyx_n_s_NODEINFEASIBLE); + Py_CLEAR(clear_module_state->__pyx_n_s_NODELIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_NODESOLVED); + Py_CLEAR(clear_module_state->__pyx_n_s_NONE); + Py_CLEAR(clear_module_state->__pyx_n_s_NOTSOLVED); + Py_CLEAR(clear_module_state->__pyx_n_s_NUMERICS); + Py_CLEAR(clear_module_state->__pyx_n_s_Node); + Py_CLEAR(clear_module_state->__pyx_n_s_Node___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Node___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getAddedConss); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getDepth); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getDomchg); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getEstimate); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getLowerbound); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getNAddedConss); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getNDomchg); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getNParentBranchings); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getNumber); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getParent); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getParentBranchings); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_getType); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_isActive); + Py_CLEAR(clear_module_state->__pyx_n_s_Node_isPropagatedAgain); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel_nodecomp); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel_nodeexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel_nodeexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel_nodefree); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel_nodeinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel_nodeinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Nodesel_nodeselect); + Py_CLEAR(clear_module_state->__pyx_kp_u_Nonlinear_objective_functions_ar); + Py_CLEAR(clear_module_state->__pyx_n_s_NotImplementedError); + Py_CLEAR(clear_module_state->__pyx_kp_u_Not_a_valid_parameter_name); + Py_CLEAR(clear_module_state->__pyx_n_s_OBJCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_OBJLIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_OFF); + Py_CLEAR(clear_module_state->__pyx_n_s_OPTIMAL); + Py_CLEAR(clear_module_state->__pyx_n_s_OPTIMALITY); + Py_CLEAR(clear_module_state->__pyx_n_u_ORcons); + Py_CLEAR(clear_module_state->__pyx_n_s_Op); + Py_CLEAR(clear_module_state->__pyx_n_s_Operator); + Py_CLEAR(clear_module_state->__pyx_n_s_PATCH); + Py_CLEAR(clear_module_state->__pyx_n_s_PHASEFEAS); + Py_CLEAR(clear_module_state->__pyx_n_s_PHASEIMPROVE); + Py_CLEAR(clear_module_state->__pyx_n_s_PHASEPROOF); + Py_CLEAR(clear_module_state->__pyx_n_s_POORSOLFOUND); + Py_CLEAR(clear_module_state->__pyx_n_s_PRESOLVED); + Py_CLEAR(clear_module_state->__pyx_n_s_PRESOLVEROUND); + Py_CLEAR(clear_module_state->__pyx_n_s_PRESOLVING); + Py_CLEAR(clear_module_state->__pyx_n_s_PRIMALLIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_PROBINGNODE); + Py_CLEAR(clear_module_state->__pyx_n_s_PROBLEM); + Py_CLEAR(clear_module_state->__pyx_n_s_PSEUDO); + Py_CLEAR(clear_module_state->__pyx_n_s_PSEUDOFORK); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___setsta); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_BRANCHDIR); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_BRANCHDIR___reduce_cytho); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_BRANCHDIR___setstate_cyt); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_CALL); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_EVENTTYPE); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_EVENTTYPE___reduce_cytho); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_EVENTTYPE___setstate_cyt); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_HEURTIMING); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_HEURTIMING___reduce_cyth); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_HEURTIMING___setstate_cy); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_LPSOLSTAT); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_LPSOLSTAT___reduce_cytho); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_LPSOLSTAT___setstate_cyt); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_NODETYPE); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_NODETYPE___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_NODETYPE___setstate_cyth); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PARAMEMPHASIS); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PARAMEMPHASIS___reduce_c); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PARAMEMPHASIS___setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PARAMSETTING); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PARAMSETTING___reduce_cy); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PARAMSETTING___setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PRESOLTIMING); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PRESOLTIMING___reduce_cy); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PRESOLTIMING___setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PROPTIMING); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PROPTIMING___reduce_cyth); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_PROPTIMING___setstate_cy); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_RESULT); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_RESULT___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_RESULT___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_ROWORIGINTYPE); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_ROWORIGINTYPE___reduce_c); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_ROWORIGINTYPE___setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_STAGE); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_STAGE___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_STAGE___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_STATUS); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_STATUS___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PY_SCIP_STATUS___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_PowExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_PowExpr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_PowExpr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol_presolexec); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol_presolexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol_presolexitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol_presolfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol_presolinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Presol_presolinitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer_pricerexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer_pricerexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer_pricerfarkas); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer_pricerfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer_pricerinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer_pricerinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Pricer_pricerredcost); + Py_CLEAR(clear_module_state->__pyx_n_s_ProdExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_ProdExpr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ProdExpr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propexec); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propexitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propinitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_proppresol); + Py_CLEAR(clear_module_state->__pyx_n_s_Prop_propresprop); + Py_CLEAR(clear_module_state->__pyx_kp_u_Provide_BOOLEAN_value_as_rhsvar); + Py_CLEAR(clear_module_state->__pyx_n_s_PyCons); + Py_CLEAR(clear_module_state->__pyx_n_s_PyRow); + Py_CLEAR(clear_module_state->__pyx_n_s_REDUCEDDOM); + Py_CLEAR(clear_module_state->__pyx_n_s_REFOCUSNODE); + Py_CLEAR(clear_module_state->__pyx_n_s_RELAX); + Py_CLEAR(clear_module_state->__pyx_n_s_REOPT); + Py_CLEAR(clear_module_state->__pyx_n_s_RESTARTLIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWADDEDLP); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWADDEDSEPA); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWCOEFCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWCONSTCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWDELETEDLP); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWDELETEDSEPA); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWEVENT); + Py_CLEAR(clear_module_state->__pyx_n_s_ROWSIDECHANGED); + Py_CLEAR(clear_module_state->__pyx_kp_u_Ranged_ExprCons_is_not_well_defi); + Py_CLEAR(clear_module_state->__pyx_n_s_Reader); + Py_CLEAR(clear_module_state->__pyx_n_s_Reader___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Reader___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Reader_readerfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Reader_readerread); + Py_CLEAR(clear_module_state->__pyx_n_s_Reader_readerwrite); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax_relaxexec); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax_relaxexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax_relaxexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax_relaxfree); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax_relaxinit); + Py_CLEAR(clear_module_state->__pyx_n_s_Relax_relaxinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Row); + Py_CLEAR(clear_module_state->__pyx_n_s_Row___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Row___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getBasisStatus); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getCols); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getConsOriginConshdlrtype); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getConstant); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getLPPos); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getLhs); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getNLPNonz); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getNNonz); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getNorm); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getOrigintype); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getRhs); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_getVals); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_isInGlobalCutpool); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_isIntegral); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_isLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_isModifiable); + Py_CLEAR(clear_module_state->__pyx_n_s_Row_isRemovable); + Py_CLEAR(clear_module_state->__pyx_n_s_SCIP_BOUNDTYPE_TO_STRING); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_a_required_plugin_was_not_f); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_cannot_create_file); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_does_not_support_nonlinear); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_error_in_LP_solver); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_error_in_input_data); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_file_not_found_error); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_insufficient_memory_error); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_maximal_branching_depth_lev); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_method_cannot_be_called_at); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_method_returned_an_invalid); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_no_problem_exists); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_read_error); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_reading_solution_from_file); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_returned_base_status_zero_f); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_returned_unknown_base_statu); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_the_given_key_is_already_ex); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_the_parameter_is_not_of_the); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_the_parameter_with_the_give); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_the_value_is_invalid_for_th); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_unknown_return_code); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_unspecified_error); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_was_compiled_without_task_p); + Py_CLEAR(clear_module_state->__pyx_kp_u_SCIP_write_error); + Py_CLEAR(clear_module_state->__pyx_n_u_SCIPgetSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_SEPA); + Py_CLEAR(clear_module_state->__pyx_n_s_SEPARATED); + Py_CLEAR(clear_module_state->__pyx_n_s_SIBLING); + Py_CLEAR(clear_module_state->__pyx_n_s_SOLEVENT); + Py_CLEAR(clear_module_state->__pyx_n_s_SOLFOUND); + Py_CLEAR(clear_module_state->__pyx_n_s_SOLLIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_SOLVED); + Py_CLEAR(clear_module_state->__pyx_n_s_SOLVELP); + Py_CLEAR(clear_module_state->__pyx_n_s_SOLVING); + Py_CLEAR(clear_module_state->__pyx_n_u_SOS1cons); + Py_CLEAR(clear_module_state->__pyx_n_u_SOS2cons); + Py_CLEAR(clear_module_state->__pyx_n_s_STALLNODELIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_SUBROOT); + Py_CLEAR(clear_module_state->__pyx_n_s_SUCCESS); + Py_CLEAR(clear_module_state->__pyx_n_s_SUSPENDED); + Py_CLEAR(clear_module_state->__pyx_n_s_SYNC); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa_sepaexeclp); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa_sepaexecsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa_sepaexit); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa_sepaexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa_sepafree); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa_sepainit); + Py_CLEAR(clear_module_state->__pyx_n_s_Sepa_sepainitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_Solution); + Py_CLEAR(clear_module_state->__pyx_n_s_Solution___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Solution___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Solution__checkStage); + Py_CLEAR(clear_module_state->__pyx_n_s_Solution__evaluate); + Py_CLEAR(clear_module_state->__pyx_n_s_StageNames); + Py_CLEAR(clear_module_state->__pyx_n_s_StopIteration); + Py_CLEAR(clear_module_state->__pyx_n_s_SumExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_SumExpr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_SumExpr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_TIMELIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_TOTALNODELIMIT); + Py_CLEAR(clear_module_state->__pyx_n_s_TRANSFORMED); + Py_CLEAR(clear_module_state->__pyx_n_s_TRANSFORMING); + Py_CLEAR(clear_module_state->__pyx_n_s_Term); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___add); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___eq); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___getitem); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___hash); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___init); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___init___locals_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___init___locals_lambda); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___len); + Py_CLEAR(clear_module_state->__pyx_n_s_Term___repr); + Py_CLEAR(clear_module_state->__pyx_kp_u_Term_s); + Py_CLEAR(clear_module_state->__pyx_kp_u_The_constraint_handler_s_does_no); + Py_CLEAR(clear_module_state->__pyx_kp_u_The_given_capsule_does_not_conta); + Py_CLEAR(clear_module_state->__pyx_kp_u_The_given_variable_is_not_a_pyva); + Py_CLEAR(clear_module_state->__pyx_kp_u_The_problem_does_not_have_a_prim); + Py_CLEAR(clear_module_state->__pyx_kp_s_This_is_a_monomial_term); + Py_CLEAR(clear_module_state->__pyx_kp_u_To_create_a_solution_you_should); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s_UBCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_UBRELAXED); + Py_CLEAR(clear_module_state->__pyx_n_s_UBTIGHTENED); + Py_CLEAR(clear_module_state->__pyx_n_s_UNBOUNDED); + Py_CLEAR(clear_module_state->__pyx_n_s_UNBOUNDEDRAY); + Py_CLEAR(clear_module_state->__pyx_n_s_UNKNOWN); + Py_CLEAR(clear_module_state->__pyx_n_s_UNSPEC); + Py_CLEAR(clear_module_state->__pyx_n_s_UPWARDS); + Py_CLEAR(clear_module_state->__pyx_n_s_USERINTERRUPT); + Py_CLEAR(clear_module_state->__pyx_n_s_UnaryExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_UnaryExpr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_UnaryExpr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Union); + Py_CLEAR(clear_module_state->__pyx_kp_s_Union_Expr_GenExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_VARADDED); + Py_CLEAR(clear_module_state->__pyx_n_s_VARCHANGED); + Py_CLEAR(clear_module_state->__pyx_n_s_VARDELETED); + Py_CLEAR(clear_module_state->__pyx_n_s_VAREVENT); + Py_CLEAR(clear_module_state->__pyx_n_s_VARFIXED); + Py_CLEAR(clear_module_state->__pyx_n_s_VARUNLOCKED); + Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); + Py_CLEAR(clear_module_state->__pyx_n_s_VarExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_VarExpr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_VarExpr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getCol); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getIndex); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getLPSol); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getLbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getLbLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getLbOriginal); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getObj); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getUbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getUbLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_getUbOriginal); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_isInLP); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_isOriginal); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_ptr); + Py_CLEAR(clear_module_state->__pyx_n_s_Variable_vtype); + Py_CLEAR(clear_module_state->__pyx_n_s_Warning); + Py_CLEAR(clear_module_state->__pyx_n_u_XORcons); + Py_CLEAR(clear_module_state->__pyx_n_s_ZeroDivisionError); + Py_CLEAR(clear_module_state->__pyx_kp_u__10); + Py_CLEAR(clear_module_state->__pyx_kp_u__114); + Py_CLEAR(clear_module_state->__pyx_n_s__1188); + Py_CLEAR(clear_module_state->__pyx_n_s__126); + Py_CLEAR(clear_module_state->__pyx_kp_u__126); + Py_CLEAR(clear_module_state->__pyx_kp_u__162); + Py_CLEAR(clear_module_state->__pyx_kp_u__163); + Py_CLEAR(clear_module_state->__pyx_kp_u__164); + Py_CLEAR(clear_module_state->__pyx_kp_u__165); + Py_CLEAR(clear_module_state->__pyx_kp_u__2); + Py_CLEAR(clear_module_state->__pyx_kp_u__441); + Py_CLEAR(clear_module_state->__pyx_kp_u__442); + Py_CLEAR(clear_module_state->__pyx_kp_u__6); + Py_CLEAR(clear_module_state->__pyx_kp_u__79); + Py_CLEAR(clear_module_state->__pyx_kp_u__89); + Py_CLEAR(clear_module_state->__pyx_kp_u__9); + Py_CLEAR(clear_module_state->__pyx_n_u__94); + Py_CLEAR(clear_module_state->__pyx_n_u_abs); + Py_CLEAR(clear_module_state->__pyx_n_s_absfile); + Py_CLEAR(clear_module_state->__pyx_n_s_abspath); + Py_CLEAR(clear_module_state->__pyx_n_s_activateBenders); + Py_CLEAR(clear_module_state->__pyx_n_s_activeone); + Py_CLEAR(clear_module_state->__pyx_n_s_activity); + Py_CLEAR(clear_module_state->__pyx_n_s_add); + Py_CLEAR(clear_module_state->__pyx_n_s_addBendersSubproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_addCoefLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_addCol); + Py_CLEAR(clear_module_state->__pyx_n_s_addCols); + Py_CLEAR(clear_module_state->__pyx_n_s_addCols_locals_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_addCons); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsAnd); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsCardinality); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsCoeff); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsDisjunction); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsDisjunction_locals_ensure); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsElemDisjunction); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsIndicator); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsNode); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsOr); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsSOS1); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsSOS2); + Py_CLEAR(clear_module_state->__pyx_n_s_addConsXor); + Py_CLEAR(clear_module_state->__pyx_n_s_addConss); + Py_CLEAR(clear_module_state->__pyx_n_s_addConss_locals_ensure_iterable); + Py_CLEAR(clear_module_state->__pyx_n_s_addCut); + Py_CLEAR(clear_module_state->__pyx_n_s_addExprNonlinear); + Py_CLEAR(clear_module_state->__pyx_kp_u_addExprNonlinear_can_only_be_cal); + Py_CLEAR(clear_module_state->__pyx_kp_u_addExprNonlinear_cannot_be_calle); + Py_CLEAR(clear_module_state->__pyx_n_s_addObjoffset); + Py_CLEAR(clear_module_state->__pyx_n_s_addPoolCut); + Py_CLEAR(clear_module_state->__pyx_n_s_addPyCons); + Py_CLEAR(clear_module_state->__pyx_n_s_addRow); + Py_CLEAR(clear_module_state->__pyx_n_s_addRowDive); + Py_CLEAR(clear_module_state->__pyx_n_s_addRows); + Py_CLEAR(clear_module_state->__pyx_n_s_addRows_locals_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_addSol); + Py_CLEAR(clear_module_state->__pyx_n_s_addVar); + Py_CLEAR(clear_module_state->__pyx_n_s_addVarLocks); + Py_CLEAR(clear_module_state->__pyx_n_s_addVarSOS1); + Py_CLEAR(clear_module_state->__pyx_n_s_addVarSOS2); + Py_CLEAR(clear_module_state->__pyx_n_s_addVarToRow); + Py_CLEAR(clear_module_state->__pyx_n_s_add_2); + Py_CLEAR(clear_module_state->__pyx_n_s_addedconss); + Py_CLEAR(clear_module_state->__pyx_n_s_addedconsssize); + Py_CLEAR(clear_module_state->__pyx_n_s_allowaddcons); + Py_CLEAR(clear_module_state->__pyx_n_s_allowlocal); + Py_CLEAR(clear_module_state->__pyx_n_s_append); + Py_CLEAR(clear_module_state->__pyx_n_s_appendVarSOS1); + Py_CLEAR(clear_module_state->__pyx_n_s_appendVarSOS2); + Py_CLEAR(clear_module_state->__pyx_n_s_applyCutsProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_args); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_attr); + Py_CLEAR(clear_module_state->__pyx_n_s_auxvar); + Py_CLEAR(clear_module_state->__pyx_n_s_auxvar_2); + Py_CLEAR(clear_module_state->__pyx_n_u_auxviol); + Py_CLEAR(clear_module_state->__pyx_n_s_backtrackProbing); + Py_CLEAR(clear_module_state->__pyx_n_u_basic); + Py_CLEAR(clear_module_state->__pyx_n_s_bdtype); + Py_CLEAR(clear_module_state->__pyx_n_s_beg); + Py_CLEAR(clear_module_state->__pyx_n_s_benders); + Py_CLEAR(clear_module_state->__pyx_n_s_benders_2); + Py_CLEAR(clear_module_state->__pyx_n_s_benderscreatesub); + Py_CLEAR(clear_module_state->__pyx_n_s_benderscut); + Py_CLEAR(clear_module_state->__pyx_n_s_benderscutexec); + Py_CLEAR(clear_module_state->__pyx_n_s_benderscutexit); + Py_CLEAR(clear_module_state->__pyx_n_s_benderscutexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_benderscutfree); + Py_CLEAR(clear_module_state->__pyx_n_s_benderscutinit); + Py_CLEAR(clear_module_state->__pyx_n_s_benderscutinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersexit); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersexitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersfree); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersfreesub); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersgetvar); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersinit); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersinitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_bendersinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_benderspostsolve); + Py_CLEAR(clear_module_state->__pyx_n_s_benderspresubsolve); + Py_CLEAR(clear_module_state->__pyx_n_s_benderssolvesub); + Py_CLEAR(clear_module_state->__pyx_n_s_benderssolvesubconvex); + Py_CLEAR(clear_module_state->__pyx_n_u_bestsollimit); + Py_CLEAR(clear_module_state->__pyx_n_s_bilincoef); + Py_CLEAR(clear_module_state->__pyx_n_s_bilinterm1); + Py_CLEAR(clear_module_state->__pyx_n_s_bilinterm2); + Py_CLEAR(clear_module_state->__pyx_n_s_bilinterms); + Py_CLEAR(clear_module_state->__pyx_n_s_binVar); + Py_CLEAR(clear_module_state->__pyx_n_s_binds); + Py_CLEAR(clear_module_state->__pyx_n_s_binvar); + Py_CLEAR(clear_module_state->__pyx_n_s_binvars); + Py_CLEAR(clear_module_state->__pyx_n_s_both); + Py_CLEAR(clear_module_state->__pyx_n_s_boundconstraint); + Py_CLEAR(clear_module_state->__pyx_n_s_bounded); + Py_CLEAR(clear_module_state->__pyx_n_s_boundtypes); + Py_CLEAR(clear_module_state->__pyx_n_s_branchVar); + Py_CLEAR(clear_module_state->__pyx_n_s_branchVarVal); + Py_CLEAR(clear_module_state->__pyx_n_s_branchbounds); + Py_CLEAR(clear_module_state->__pyx_n_s_branchdir); + Py_CLEAR(clear_module_state->__pyx_n_s_branchexecext); + Py_CLEAR(clear_module_state->__pyx_kp_u_branchexecext_is_a_fundamental_c); + Py_CLEAR(clear_module_state->__pyx_n_s_branchexeclp); + Py_CLEAR(clear_module_state->__pyx_kp_u_branchexeclp_is_a_fundamental_ca); + Py_CLEAR(clear_module_state->__pyx_n_s_branchexecps); + Py_CLEAR(clear_module_state->__pyx_kp_u_branchexecps_is_a_fundamental_ca); + Py_CLEAR(clear_module_state->__pyx_n_s_branchexit); + Py_CLEAR(clear_module_state->__pyx_n_s_branchexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_branchfree); + Py_CLEAR(clear_module_state->__pyx_n_s_branchinit); + Py_CLEAR(clear_module_state->__pyx_n_s_branchinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_branchrule); + Py_CLEAR(clear_module_state->__pyx_n_s_branchvars); + Py_CLEAR(clear_module_state->__pyx_n_s_buildGenExprObj); + Py_CLEAR(clear_module_state->__pyx_n_s_c); + Py_CLEAR(clear_module_state->__pyx_n_u_c); + Py_CLEAR(clear_module_state->__pyx_n_s_c_beg); + Py_CLEAR(clear_module_state->__pyx_n_s_c_binds); + Py_CLEAR(clear_module_state->__pyx_n_s_c_coefs); + Py_CLEAR(clear_module_state->__pyx_n_s_c_col); + Py_CLEAR(clear_module_state->__pyx_n_s_c_dualsol); + Py_CLEAR(clear_module_state->__pyx_n_s_c_inds); + Py_CLEAR(clear_module_state->__pyx_n_s_c_lb); + Py_CLEAR(clear_module_state->__pyx_n_s_c_lbs); + Py_CLEAR(clear_module_state->__pyx_n_s_c_lhs); + Py_CLEAR(clear_module_state->__pyx_n_s_c_lhss); + Py_CLEAR(clear_module_state->__pyx_n_s_c_obj); + Py_CLEAR(clear_module_state->__pyx_n_s_c_objs); + Py_CLEAR(clear_module_state->__pyx_n_s_c_path); + Py_CLEAR(clear_module_state->__pyx_n_s_c_primalsol); + Py_CLEAR(clear_module_state->__pyx_n_s_c_ray); + Py_CLEAR(clear_module_state->__pyx_n_s_c_redcost); + Py_CLEAR(clear_module_state->__pyx_n_s_c_rhs); + Py_CLEAR(clear_module_state->__pyx_n_s_c_rhss); + Py_CLEAR(clear_module_state->__pyx_n_s_c_row); + Py_CLEAR(clear_module_state->__pyx_n_s_c_ub); + Py_CLEAR(clear_module_state->__pyx_n_s_c_ubs); + Py_CLEAR(clear_module_state->__pyx_n_s_cacheRowExtensions); + Py_CLEAR(clear_module_state->__pyx_n_s_calcChildEstimate); + Py_CLEAR(clear_module_state->__pyx_n_s_calcNodeselPriority); + Py_CLEAR(clear_module_state->__pyx_kp_u_can_only_be_called_with_a_valid); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_BoundChange_with_S); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_Column_with_SCIP_C); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_Constraint_with_SC); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_DomainChanges_with); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_Event_with_SCIP_EV); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_Model_with_SCIP_NU); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_NLRow_with_SCIP_NL); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_Row_with_SCIP_ROW); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_Solution_with_SCIP); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_create_Variable_with_SCIP); + Py_CLEAR(clear_module_state->__pyx_kp_u_cannot_divide_by_0); + Py_CLEAR(clear_module_state->__pyx_n_s_capsule); + Py_CLEAR(clear_module_state->__pyx_n_s_cardval); + Py_CLEAR(clear_module_state->__pyx_n_s_catchEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_catchRowEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_catchVarEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_category); + Py_CLEAR(clear_module_state->__pyx_n_s_cfile); + Py_CLEAR(clear_module_state->__pyx_n_s_chckpriority); + Py_CLEAR(clear_module_state->__pyx_n_s_check); + Py_CLEAR(clear_module_state->__pyx_n_u_check); + Py_CLEAR(clear_module_state->__pyx_n_s_checkBendersSubproblemOptimality); + Py_CLEAR(clear_module_state->__pyx_n_s_checkQuadraticNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_checkSol); + Py_CLEAR(clear_module_state->__pyx_n_s_checkStage); + Py_CLEAR(clear_module_state->__pyx_n_s_checkbounds); + Py_CLEAR(clear_module_state->__pyx_n_s_checkint); + Py_CLEAR(clear_module_state->__pyx_n_s_checkintegrality); + Py_CLEAR(clear_module_state->__pyx_n_s_checklprows); + Py_CLEAR(clear_module_state->__pyx_n_s_checktype); + Py_CLEAR(clear_module_state->__pyx_n_s_chgBound); + Py_CLEAR(clear_module_state->__pyx_n_s_chgCoef); + Py_CLEAR(clear_module_state->__pyx_n_s_chgCoefLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_chgLhs); + Py_CLEAR(clear_module_state->__pyx_n_s_chgObj); + Py_CLEAR(clear_module_state->__pyx_n_s_chgReoptObjective); + Py_CLEAR(clear_module_state->__pyx_n_s_chgRhs); + Py_CLEAR(clear_module_state->__pyx_n_s_chgRowLhsDive); + Py_CLEAR(clear_module_state->__pyx_n_s_chgRowRhsDive); + Py_CLEAR(clear_module_state->__pyx_n_s_chgSide); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarBranchPriority); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarLb); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarLbDive); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarLbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarLbNode); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarLbProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarObjDive); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarObjProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarType); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarUb); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarUbDive); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarUbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarUbNode); + Py_CLEAR(clear_module_state->__pyx_n_s_chgVarUbProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_child); + Py_CLEAR(clear_module_state->__pyx_n_s_children); + Py_CLEAR(clear_module_state->__pyx_n_s_children_2); + Py_CLEAR(clear_module_state->__pyx_n_s_childrenexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_chr); + Py_CLEAR(clear_module_state->__pyx_kp_u_cip); + Py_CLEAR(clear_module_state->__pyx_n_s_class); + Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); + Py_CLEAR(clear_module_state->__pyx_n_s_clear); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_close); + Py_CLEAR(clear_module_state->__pyx_n_s_closefd); + Py_CLEAR(clear_module_state->__pyx_n_s_cname); + Py_CLEAR(clear_module_state->__pyx_n_s_coef); + Py_CLEAR(clear_module_state->__pyx_n_s_coeff); + Py_CLEAR(clear_module_state->__pyx_kp_u_coefficients_not_available_for_c); + Py_CLEAR(clear_module_state->__pyx_n_s_coeffs); + Py_CLEAR(clear_module_state->__pyx_n_s_coeffs_2); + Py_CLEAR(clear_module_state->__pyx_n_s_coeffs_array); + Py_CLEAR(clear_module_state->__pyx_n_s_coefs); + Py_CLEAR(clear_module_state->__pyx_n_s_col); + Py_CLEAR(clear_module_state->__pyx_n_s_collections_abc); + Py_CLEAR(clear_module_state->__pyx_n_s_cols); + Py_CLEAR(clear_module_state->__pyx_n_s_comments); + Py_CLEAR(clear_module_state->__pyx_n_s_completely); + Py_CLEAR(clear_module_state->__pyx_n_s_computeBestSolSubproblems); + Py_CLEAR(clear_module_state->__pyx_n_s_confvar); + Py_CLEAR(clear_module_state->__pyx_n_s_cons); + Py_CLEAR(clear_module_state->__pyx_n_s_consactive); + Py_CLEAR(clear_module_state->__pyx_n_s_conscheck); + Py_CLEAR(clear_module_state->__pyx_n_s_conscopy); + Py_CLEAR(clear_module_state->__pyx_n_s_consdeactive); + Py_CLEAR(clear_module_state->__pyx_n_s_consdelete); + Py_CLEAR(clear_module_state->__pyx_n_s_consdelvars); + Py_CLEAR(clear_module_state->__pyx_n_s_consdisable); + Py_CLEAR(clear_module_state->__pyx_n_s_consenable); + Py_CLEAR(clear_module_state->__pyx_n_s_consenfolp); + Py_CLEAR(clear_module_state->__pyx_n_s_consenfops); + Py_CLEAR(clear_module_state->__pyx_n_s_consenforelax); + Py_CLEAR(clear_module_state->__pyx_n_s_consexit); + Py_CLEAR(clear_module_state->__pyx_n_s_consexitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_consexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_consfree); + Py_CLEAR(clear_module_state->__pyx_n_s_consgetdivebdchgs); + Py_CLEAR(clear_module_state->__pyx_n_s_consgetnvars); + Py_CLEAR(clear_module_state->__pyx_n_s_consgetpermsymgraph); + Py_CLEAR(clear_module_state->__pyx_n_s_consgetsignedpermsymgraph); + Py_CLEAR(clear_module_state->__pyx_n_s_consgetvars); + Py_CLEAR(clear_module_state->__pyx_n_s_conshdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_conshdrlname); + Py_CLEAR(clear_module_state->__pyx_n_s_consinit); + Py_CLEAR(clear_module_state->__pyx_n_s_consinitlp); + Py_CLEAR(clear_module_state->__pyx_n_s_consinitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_consinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_conslock); + Py_CLEAR(clear_module_state->__pyx_n_s_consparse); + Py_CLEAR(clear_module_state->__pyx_n_s_conspresol); + Py_CLEAR(clear_module_state->__pyx_n_s_consprint); + Py_CLEAR(clear_module_state->__pyx_n_s_consprop); + Py_CLEAR(clear_module_state->__pyx_n_s_consresprop); + Py_CLEAR(clear_module_state->__pyx_n_s_conss); + Py_CLEAR(clear_module_state->__pyx_n_s_conss_2); + Py_CLEAR(clear_module_state->__pyx_n_s_conssepalp); + Py_CLEAR(clear_module_state->__pyx_n_s_conssepasol); + Py_CLEAR(clear_module_state->__pyx_n_s_const); + Py_CLEAR(clear_module_state->__pyx_n_u_const); + Py_CLEAR(clear_module_state->__pyx_n_s_constant); + Py_CLEAR(clear_module_state->__pyx_n_s_constraint); + Py_CLEAR(clear_module_state->__pyx_kp_u_constraint_is_not_nonlinear); + Py_CLEAR(clear_module_state->__pyx_kp_u_constraint_is_not_quadratic); + Py_CLEAR(clear_module_state->__pyx_n_s_constraints); + Py_CLEAR(clear_module_state->__pyx_kp_u_constraints_benders_active); + Py_CLEAR(clear_module_state->__pyx_kp_u_constraints_benderslp_active); + Py_CLEAR(clear_module_state->__pyx_n_s_constrans); + Py_CLEAR(clear_module_state->__pyx_n_s_constructLP); + Py_CLEAR(clear_module_state->__pyx_n_s_constype); + Py_CLEAR(clear_module_state->__pyx_n_s_consvars); + Py_CLEAR(clear_module_state->__pyx_n_s_contvars); + Py_CLEAR(clear_module_state->__pyx_n_s_copy); + Py_CLEAR(clear_module_state->__pyx_n_s_cos); + Py_CLEAR(clear_module_state->__pyx_n_u_cos); + Py_CLEAR(clear_module_state->__pyx_kp_u_could_not_change_variable_type_o); + Py_CLEAR(clear_module_state->__pyx_n_s_count); + Py_CLEAR(clear_module_state->__pyx_n_s_createChild); + Py_CLEAR(clear_module_state->__pyx_n_s_createCons); + Py_CLEAR(clear_module_state->__pyx_n_s_createConsFromExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_createConsGenNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_createConsLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_createConsNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_createConsQuadratic); + Py_CLEAR(clear_module_state->__pyx_n_s_createEmptyRowSepa); + Py_CLEAR(clear_module_state->__pyx_n_s_createEmptyRowUnspec); + Py_CLEAR(clear_module_state->__pyx_n_s_createOrigSol); + Py_CLEAR(clear_module_state->__pyx_n_s_createPartialSol); + Py_CLEAR(clear_module_state->__pyx_n_s_createProbBasic); + Py_CLEAR(clear_module_state->__pyx_n_s_createSol); + Py_CLEAR(clear_module_state->__pyx_n_s_createscip); + Py_CLEAR(clear_module_state->__pyx_n_s_cut); + Py_CLEAR(clear_module_state->__pyx_n_s_cutlp); + Py_CLEAR(clear_module_state->__pyx_n_s_cutoff); + Py_CLEAR(clear_module_state->__pyx_n_s_cutpseudo); + Py_CLEAR(clear_module_state->__pyx_n_s_cutrelax); + Py_CLEAR(clear_module_state->__pyx_n_s_cuts); + Py_CLEAR(clear_module_state->__pyx_n_u_cuts); + Py_CLEAR(clear_module_state->__pyx_n_s_cutsel); + Py_CLEAR(clear_module_state->__pyx_n_s_cutselexit); + Py_CLEAR(clear_module_state->__pyx_n_s_cutselexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_cutselfree); + Py_CLEAR(clear_module_state->__pyx_n_s_cutselinit); + Py_CLEAR(clear_module_state->__pyx_n_s_cutselinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_cutselselect); + Py_CLEAR(clear_module_state->__pyx_n_s_d); + Py_CLEAR(clear_module_state->__pyx_n_s_defaultPlugins); + Py_CLEAR(clear_module_state->__pyx_n_s_deg); + Py_CLEAR(clear_module_state->__pyx_n_s_degree); + Py_CLEAR(clear_module_state->__pyx_n_s_degree_locals_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_delCoefLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_delCols); + Py_CLEAR(clear_module_state->__pyx_n_s_delCons); + Py_CLEAR(clear_module_state->__pyx_n_s_delConsLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_delRows); + Py_CLEAR(clear_module_state->__pyx_n_s_delVar); + Py_CLEAR(clear_module_state->__pyx_n_s_delay); + Py_CLEAR(clear_module_state->__pyx_n_s_delayed); + Py_CLEAR(clear_module_state->__pyx_n_s_delayprop); + Py_CLEAR(clear_module_state->__pyx_n_s_delaysepa); + Py_CLEAR(clear_module_state->__pyx_n_s_deleted); + Py_CLEAR(clear_module_state->__pyx_n_s_des); + Py_CLEAR(clear_module_state->__pyx_n_s_desc); + Py_CLEAR(clear_module_state->__pyx_n_s_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_dict_2); + Py_CLEAR(clear_module_state->__pyx_n_s_dis); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_n_s_disablePropagation); + Py_CLEAR(clear_module_state->__pyx_n_s_disj_cons); + Py_CLEAR(clear_module_state->__pyx_n_s_dispchar); + Py_CLEAR(clear_module_state->__pyx_n_s_div); + Py_CLEAR(clear_module_state->__pyx_n_s_doc); + Py_CLEAR(clear_module_state->__pyx_n_s_domchg); + Py_CLEAR(clear_module_state->__pyx_n_s_downchild); + Py_CLEAR(clear_module_state->__pyx_n_s_dropEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_dropRowEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_dropVarEvent); + Py_CLEAR(clear_module_state->__pyx_n_s_dual); + Py_CLEAR(clear_module_state->__pyx_kp_u_dual_solution_values_not_availab); + Py_CLEAR(clear_module_state->__pyx_n_u_duallimit); + Py_CLEAR(clear_module_state->__pyx_n_s_dualsol); + Py_CLEAR(clear_module_state->__pyx_n_s_dualsol_2); + Py_CLEAR(clear_module_state->__pyx_n_s_dummy_boundtypes); + Py_CLEAR(clear_module_state->__pyx_n_s_dummy_branchbounds); + Py_CLEAR(clear_module_state->__pyx_n_s_dummy_branchvars); + Py_CLEAR(clear_module_state->__pyx_n_s_dynamic); + Py_CLEAR(clear_module_state->__pyx_n_u_dynamic); + Py_CLEAR(clear_module_state->__pyx_n_s_e); + Py_CLEAR(clear_module_state->__pyx_n_s_eagerfreq); + Py_CLEAR(clear_module_state->__pyx_n_s_elem); + Py_CLEAR(clear_module_state->__pyx_n_s_enable); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_enableReoptimization); + Py_CLEAR(clear_module_state->__pyx_n_s_enablepricing); + Py_CLEAR(clear_module_state->__pyx_n_s_endDive); + Py_CLEAR(clear_module_state->__pyx_n_s_endProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_enfopriority); + Py_CLEAR(clear_module_state->__pyx_n_s_enforce); + Py_CLEAR(clear_module_state->__pyx_n_u_enforce); + Py_CLEAR(clear_module_state->__pyx_n_s_enfotype); + Py_CLEAR(clear_module_state->__pyx_n_s_ensure_iterable); + Py_CLEAR(clear_module_state->__pyx_n_s_enter); + Py_CLEAR(clear_module_state->__pyx_n_s_entries); + Py_CLEAR(clear_module_state->__pyx_n_s_entrieslist); + Py_CLEAR(clear_module_state->__pyx_n_s_entry); + Py_CLEAR(clear_module_state->__pyx_n_s_enumerate); + Py_CLEAR(clear_module_state->__pyx_n_s_epsilon); + Py_CLEAR(clear_module_state->__pyx_n_s_eq); + Py_CLEAR(clear_module_state->__pyx_n_s_eqchild); + Py_CLEAR(clear_module_state->__pyx_n_s_error); + Py_CLEAR(clear_module_state->__pyx_n_s_estimate); + Py_CLEAR(clear_module_state->__pyx_n_s_evaluate); + Py_CLEAR(clear_module_state->__pyx_n_s_event); + Py_CLEAR(clear_module_state->__pyx_kp_u_event_handler_not_found); + Py_CLEAR(clear_module_state->__pyx_n_s_eventcopy); + Py_CLEAR(clear_module_state->__pyx_n_s_eventdelete); + Py_CLEAR(clear_module_state->__pyx_n_s_eventexec); + Py_CLEAR(clear_module_state->__pyx_n_s_eventexit); + Py_CLEAR(clear_module_state->__pyx_n_s_eventexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_eventfree); + Py_CLEAR(clear_module_state->__pyx_n_s_eventhdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_eventhdlr_2); + Py_CLEAR(clear_module_state->__pyx_n_s_eventinit); + Py_CLEAR(clear_module_state->__pyx_n_s_eventinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_eventtype); + Py_CLEAR(clear_module_state->__pyx_n_s_exact); + Py_CLEAR(clear_module_state->__pyx_n_s_exit); + Py_CLEAR(clear_module_state->__pyx_n_s_exp); + Py_CLEAR(clear_module_state->__pyx_n_u_exp); + Py_CLEAR(clear_module_state->__pyx_kp_u_expected_inequality_that_has_eit); + Py_CLEAR(clear_module_state->__pyx_kp_u_expected_linear_inequality_expre); + Py_CLEAR(clear_module_state->__pyx_n_s_expo); + Py_CLEAR(clear_module_state->__pyx_n_s_exponent); + Py_CLEAR(clear_module_state->__pyx_kp_u_exponents_must_be_numbers); + Py_CLEAR(clear_module_state->__pyx_n_s_expr); + Py_CLEAR(clear_module_state->__pyx_n_s_expr_richcmp); + Py_CLEAR(clear_module_state->__pyx_n_s_expr_to_array); + Py_CLEAR(clear_module_state->__pyx_n_s_expr_to_nodes); + Py_CLEAR(clear_module_state->__pyx_n_s_ext); + Py_CLEAR(clear_module_state->__pyx_n_s_extend); + Py_CLEAR(clear_module_state->__pyx_n_s_extension); + Py_CLEAR(clear_module_state->__pyx_n_s_f); + Py_CLEAR(clear_module_state->__pyx_n_s_fabs); + Py_CLEAR(clear_module_state->__pyx_kp_u_failed); + Py_CLEAR(clear_module_state->__pyx_n_s_fdopen); + Py_CLEAR(clear_module_state->__pyx_n_s_feasFrac); + Py_CLEAR(clear_module_state->__pyx_n_s_feasibility); + Py_CLEAR(clear_module_state->__pyx_n_s_feasible); + Py_CLEAR(clear_module_state->__pyx_n_s_feastol); + Py_CLEAR(clear_module_state->__pyx_n_s_file); + Py_CLEAR(clear_module_state->__pyx_n_s_filename); + Py_CLEAR(clear_module_state->__pyx_n_s_fileno); + Py_CLEAR(clear_module_state->__pyx_n_s_firstcol); + Py_CLEAR(clear_module_state->__pyx_n_s_firstrow); + Py_CLEAR(clear_module_state->__pyx_n_s_fixVar); + Py_CLEAR(clear_module_state->__pyx_n_s_fixVarProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_fixed); + Py_CLEAR(clear_module_state->__pyx_n_s_fixedval); + Py_CLEAR(clear_module_state->__pyx_n_s_fixedvars); + Py_CLEAR(clear_module_state->__pyx_n_s_flushRowExtensions); + Py_CLEAR(clear_module_state->__pyx_n_s_fn); + Py_CLEAR(clear_module_state->__pyx_n_s_force); + Py_CLEAR(clear_module_state->__pyx_n_s_forcecut); + Py_CLEAR(clear_module_state->__pyx_n_s_forcedcuts); + Py_CLEAR(clear_module_state->__pyx_n_s_format); + Py_CLEAR(clear_module_state->__pyx_n_s_frac); + Py_CLEAR(clear_module_state->__pyx_n_s_free); + Py_CLEAR(clear_module_state->__pyx_n_s_freeBendersSubproblems); + Py_CLEAR(clear_module_state->__pyx_n_s_freeProb); + Py_CLEAR(clear_module_state->__pyx_n_s_freeReoptSolve); + Py_CLEAR(clear_module_state->__pyx_n_s_freeSol); + Py_CLEAR(clear_module_state->__pyx_n_s_freeTransform); + Py_CLEAR(clear_module_state->__pyx_n_s_freescip); + Py_CLEAR(clear_module_state->__pyx_n_s_freq); + Py_CLEAR(clear_module_state->__pyx_n_s_freqofs); + Py_CLEAR(clear_module_state->__pyx_n_s_from_ptr); + Py_CLEAR(clear_module_state->__pyx_n_u_gaplimit); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_genericnames); + Py_CLEAR(clear_module_state->__pyx_n_s_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_get); + Py_CLEAR(clear_module_state->__pyx_n_s_getActivity); + Py_CLEAR(clear_module_state->__pyx_n_s_getAddedConss); + Py_CLEAR(clear_module_state->__pyx_n_s_getBasisInds); + Py_CLEAR(clear_module_state->__pyx_n_s_getBasisStatus); + Py_CLEAR(clear_module_state->__pyx_n_s_getBendersAuxiliaryVar); + Py_CLEAR(clear_module_state->__pyx_n_s_getBendersSubproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_getBendersVar); + Py_CLEAR(clear_module_state->__pyx_n_s_getBestChild); + Py_CLEAR(clear_module_state->__pyx_n_s_getBestLeaf); + Py_CLEAR(clear_module_state->__pyx_n_s_getBestNode); + Py_CLEAR(clear_module_state->__pyx_n_s_getBestSibling); + Py_CLEAR(clear_module_state->__pyx_n_s_getBestSol); + Py_CLEAR(clear_module_state->__pyx_n_s_getBestboundNode); + Py_CLEAR(clear_module_state->__pyx_n_s_getBoundchgs); + Py_CLEAR(clear_module_state->__pyx_n_s_getBoundchgtype); + Py_CLEAR(clear_module_state->__pyx_n_s_getBounds); + Py_CLEAR(clear_module_state->__pyx_n_s_getBoundtype); + Py_CLEAR(clear_module_state->__pyx_n_s_getCol); + Py_CLEAR(clear_module_state->__pyx_n_s_getCols); + Py_CLEAR(clear_module_state->__pyx_n_s_getCondition); + Py_CLEAR(clear_module_state->__pyx_n_s_getConsNVars); + Py_CLEAR(clear_module_state->__pyx_n_s_getConsOriginConshdlrtype); + Py_CLEAR(clear_module_state->__pyx_n_s_getConsVars); + Py_CLEAR(clear_module_state->__pyx_n_s_getConshdlrName); + Py_CLEAR(clear_module_state->__pyx_n_s_getConss); + Py_CLEAR(clear_module_state->__pyx_n_s_getConstant); + Py_CLEAR(clear_module_state->__pyx_n_s_getCurrentNode); + Py_CLEAR(clear_module_state->__pyx_n_s_getCutEfficacy); + Py_CLEAR(clear_module_state->__pyx_n_s_getCutLPSolCutoffDistance); + Py_CLEAR(clear_module_state->__pyx_n_s_getDepth); + Py_CLEAR(clear_module_state->__pyx_n_s_getDomchg); + Py_CLEAR(clear_module_state->__pyx_n_s_getDual); + Py_CLEAR(clear_module_state->__pyx_n_s_getDualMultiplier); + Py_CLEAR(clear_module_state->__pyx_n_s_getDualRay); + Py_CLEAR(clear_module_state->__pyx_n_s_getDualSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_getDualbound); + Py_CLEAR(clear_module_state->__pyx_n_s_getDualboundRoot); + Py_CLEAR(clear_module_state->__pyx_n_s_getDualfarkasLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_getDualsol); + Py_CLEAR(clear_module_state->__pyx_n_s_getDualsolLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_getEstimate); + Py_CLEAR(clear_module_state->__pyx_n_s_getEventNames); + Py_CLEAR(clear_module_state->__pyx_n_s_getGap); + Py_CLEAR(clear_module_state->__pyx_n_s_getIndex); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPBInvARow); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPBInvRow); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPBasisInd); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPBranchCands); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPColsData); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPObjVal); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPPos); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPRowsData); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPSol); + Py_CLEAR(clear_module_state->__pyx_n_s_getLPSolstat); + Py_CLEAR(clear_module_state->__pyx_n_s_getLb); + Py_CLEAR(clear_module_state->__pyx_n_s_getLbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_getLbLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_getLbOriginal); + Py_CLEAR(clear_module_state->__pyx_n_s_getLhs); + Py_CLEAR(clear_module_state->__pyx_n_s_getLinearTerms); + Py_CLEAR(clear_module_state->__pyx_n_s_getLocalEstimate); + Py_CLEAR(clear_module_state->__pyx_n_s_getLowerbound); + Py_CLEAR(clear_module_state->__pyx_n_s_getNAddedConss); + Py_CLEAR(clear_module_state->__pyx_n_s_getNBestSolsFound); + Py_CLEAR(clear_module_state->__pyx_n_s_getNBinVars); + Py_CLEAR(clear_module_state->__pyx_n_s_getNChildren); + Py_CLEAR(clear_module_state->__pyx_n_s_getNConss); + Py_CLEAR(clear_module_state->__pyx_n_s_getNCountedSols); + Py_CLEAR(clear_module_state->__pyx_n_s_getNCuts); + Py_CLEAR(clear_module_state->__pyx_n_s_getNCutsApplied); + Py_CLEAR(clear_module_state->__pyx_n_s_getNDomchg); + Py_CLEAR(clear_module_state->__pyx_n_s_getNFeasibleLeaves); + Py_CLEAR(clear_module_state->__pyx_n_s_getNInfeasibleLeaves); + Py_CLEAR(clear_module_state->__pyx_n_s_getNIntVars); + Py_CLEAR(clear_module_state->__pyx_n_s_getNIterations); + Py_CLEAR(clear_module_state->__pyx_n_s_getNLPCols); + Py_CLEAR(clear_module_state->__pyx_n_s_getNLPIterations); + Py_CLEAR(clear_module_state->__pyx_n_s_getNLPNonz); + Py_CLEAR(clear_module_state->__pyx_n_s_getNLPRows); + Py_CLEAR(clear_module_state->__pyx_n_s_getNLPs); + Py_CLEAR(clear_module_state->__pyx_n_s_getNLeaves); + Py_CLEAR(clear_module_state->__pyx_n_s_getNLimSolsFound); + Py_CLEAR(clear_module_state->__pyx_n_s_getNNlRows); + Py_CLEAR(clear_module_state->__pyx_n_s_getNNodes); + Py_CLEAR(clear_module_state->__pyx_n_s_getNNonz); + Py_CLEAR(clear_module_state->__pyx_n_s_getNParentBranchings); + Py_CLEAR(clear_module_state->__pyx_n_s_getNReaders); + Py_CLEAR(clear_module_state->__pyx_n_s_getNSepaRounds); + Py_CLEAR(clear_module_state->__pyx_n_s_getNSiblings); + Py_CLEAR(clear_module_state->__pyx_n_s_getNSols); + Py_CLEAR(clear_module_state->__pyx_n_s_getNSolsFound); + Py_CLEAR(clear_module_state->__pyx_n_s_getNTotalNodes); + Py_CLEAR(clear_module_state->__pyx_n_s_getNVars); + Py_CLEAR(clear_module_state->__pyx_n_s_getName); + Py_CLEAR(clear_module_state->__pyx_n_s_getNewBound); + Py_CLEAR(clear_module_state->__pyx_n_s_getNlRowActivityBounds); + Py_CLEAR(clear_module_state->__pyx_n_s_getNlRowSolActivity); + Py_CLEAR(clear_module_state->__pyx_n_s_getNlRowSolFeasibility); + Py_CLEAR(clear_module_state->__pyx_n_s_getNlRows); + Py_CLEAR(clear_module_state->__pyx_n_s_getNode); + Py_CLEAR(clear_module_state->__pyx_n_s_getNorm); + Py_CLEAR(clear_module_state->__pyx_n_s_getNumber); + Py_CLEAR(clear_module_state->__pyx_n_s_getObj); + Py_CLEAR(clear_module_state->__pyx_n_s_getObjCoeff); + Py_CLEAR(clear_module_state->__pyx_n_s_getObjVal); + Py_CLEAR(clear_module_state->__pyx_n_s_getObjective); + Py_CLEAR(clear_module_state->__pyx_n_s_getObjectiveSense); + Py_CLEAR(clear_module_state->__pyx_n_s_getObjlimit); + Py_CLEAR(clear_module_state->__pyx_n_s_getObjoffset); + Py_CLEAR(clear_module_state->__pyx_n_s_getOldBound); + Py_CLEAR(clear_module_state->__pyx_n_s_getOp); + Py_CLEAR(clear_module_state->__pyx_n_s_getOpenNodes); + Py_CLEAR(clear_module_state->__pyx_n_s_getOrigintype); + Py_CLEAR(clear_module_state->__pyx_n_s_getParam); + Py_CLEAR(clear_module_state->__pyx_n_s_getParams); + Py_CLEAR(clear_module_state->__pyx_n_s_getParent); + Py_CLEAR(clear_module_state->__pyx_n_s_getParentBranchings); + Py_CLEAR(clear_module_state->__pyx_n_s_getPresolvingTime); + Py_CLEAR(clear_module_state->__pyx_n_s_getPrimal); + Py_CLEAR(clear_module_state->__pyx_n_s_getPrimalRay); + Py_CLEAR(clear_module_state->__pyx_n_s_getPrimalRayVal); + Py_CLEAR(clear_module_state->__pyx_n_s_getPrimalbound); + Py_CLEAR(clear_module_state->__pyx_n_s_getPrimsol); + Py_CLEAR(clear_module_state->__pyx_n_s_getProbName); + Py_CLEAR(clear_module_state->__pyx_n_s_getProbingDepth); + Py_CLEAR(clear_module_state->__pyx_n_s_getPseudoBranchCands); + Py_CLEAR(clear_module_state->__pyx_n_s_getReadingTime); + Py_CLEAR(clear_module_state->__pyx_n_s_getRedcost); + Py_CLEAR(clear_module_state->__pyx_n_s_getRhs); + Py_CLEAR(clear_module_state->__pyx_n_s_getRow); + Py_CLEAR(clear_module_state->__pyx_n_s_getRowActivity); + Py_CLEAR(clear_module_state->__pyx_n_s_getRowDualSol); + Py_CLEAR(clear_module_state->__pyx_n_s_getRowLPActivity); + Py_CLEAR(clear_module_state->__pyx_n_s_getRowLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_getRowNumIntCols); + Py_CLEAR(clear_module_state->__pyx_n_s_getRowObjParallelism); + Py_CLEAR(clear_module_state->__pyx_n_s_getRowParallelism); + Py_CLEAR(clear_module_state->__pyx_n_s_getSides); + Py_CLEAR(clear_module_state->__pyx_n_s_getSlack); + Py_CLEAR(clear_module_state->__pyx_n_s_getSlackVarIndicator); + Py_CLEAR(clear_module_state->__pyx_n_s_getSolObjVal); + Py_CLEAR(clear_module_state->__pyx_n_u_getSolObjVal); + Py_CLEAR(clear_module_state->__pyx_n_s_getSolTime); + Py_CLEAR(clear_module_state->__pyx_n_s_getSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_getSols); + Py_CLEAR(clear_module_state->__pyx_n_s_getSolvingTime); + Py_CLEAR(clear_module_state->__pyx_n_s_getStage); + Py_CLEAR(clear_module_state->__pyx_n_s_getStageName); + Py_CLEAR(clear_module_state->__pyx_n_s_getStageNames); + Py_CLEAR(clear_module_state->__pyx_n_s_getStatus); + Py_CLEAR(clear_module_state->__pyx_n_s_getTermsQuadratic); + Py_CLEAR(clear_module_state->__pyx_n_s_getTotalTime); + Py_CLEAR(clear_module_state->__pyx_n_s_getTransformedCons); + Py_CLEAR(clear_module_state->__pyx_n_s_getTransformedVar); + Py_CLEAR(clear_module_state->__pyx_n_s_getTreesizeEstimation); + Py_CLEAR(clear_module_state->__pyx_n_s_getType); + Py_CLEAR(clear_module_state->__pyx_n_s_getUb); + Py_CLEAR(clear_module_state->__pyx_n_s_getUbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_getUbLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_getUbOriginal); + Py_CLEAR(clear_module_state->__pyx_n_s_getVal); + Py_CLEAR(clear_module_state->__pyx_n_s_getVals); + Py_CLEAR(clear_module_state->__pyx_n_s_getValsLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_getVar); + Py_CLEAR(clear_module_state->__pyx_n_s_getVarDict); + Py_CLEAR(clear_module_state->__pyx_n_s_getVarLbDive); + Py_CLEAR(clear_module_state->__pyx_n_s_getVarRedcost); + Py_CLEAR(clear_module_state->__pyx_n_s_getVarUbDive); + Py_CLEAR(clear_module_state->__pyx_n_s_getVars); + Py_CLEAR(clear_module_state->__pyx_n_s_getitem); + Py_CLEAR(clear_module_state->__pyx_n_s_getitem___locals_genexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_getlocale); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_give_ownership); + Py_CLEAR(clear_module_state->__pyx_kp_u_given_coefficients_are_neither_E); + Py_CLEAR(clear_module_state->__pyx_kp_u_given_coefficients_are_not_Expr); + Py_CLEAR(clear_module_state->__pyx_kp_u_given_constraint_is_not_ExprCons); + Py_CLEAR(clear_module_state->__pyx_kp_u_given_constraint_is_not_linear_d); + Py_CLEAR(clear_module_state->__pyx_kp_u_given_constraint_is_not_quadrati); + Py_CLEAR(clear_module_state->__pyx_n_s_globalcopy); + Py_CLEAR(clear_module_state->__pyx_n_s_hasPrimalRay); + Py_CLEAR(clear_module_state->__pyx_n_s_hash); + Py_CLEAR(clear_module_state->__pyx_n_s_hashval); + Py_CLEAR(clear_module_state->__pyx_n_u_hashval); + Py_CLEAR(clear_module_state->__pyx_n_s_heur); + Py_CLEAR(clear_module_state->__pyx_n_s_heur_2); + Py_CLEAR(clear_module_state->__pyx_n_s_heurexec); + Py_CLEAR(clear_module_state->__pyx_n_s_heurexit); + Py_CLEAR(clear_module_state->__pyx_n_s_heurexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_heurfree); + Py_CLEAR(clear_module_state->__pyx_n_s_heurinit); + Py_CLEAR(clear_module_state->__pyx_n_s_heurinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_heurtiming); + Py_CLEAR(clear_module_state->__pyx_n_s_hideOutput); + Py_CLEAR(clear_module_state->__pyx_n_s_i); + Py_CLEAR(clear_module_state->__pyx_n_s_idx); + Py_CLEAR(clear_module_state->__pyx_n_s_idxs); + Py_CLEAR(clear_module_state->__pyx_n_s_implvars); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_inProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_inRepropagation); + Py_CLEAR(clear_module_state->__pyx_n_s_includeBenders); + Py_CLEAR(clear_module_state->__pyx_n_s_includeBendersDefaultCuts); + Py_CLEAR(clear_module_state->__pyx_n_s_includeBenderscut); + Py_CLEAR(clear_module_state->__pyx_n_s_includeBranchrule); + Py_CLEAR(clear_module_state->__pyx_n_s_includeConshdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_includeCutsel); + Py_CLEAR(clear_module_state->__pyx_n_s_includeDefaultPlugins); + Py_CLEAR(clear_module_state->__pyx_n_s_includeEventhdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_includeHeur); + Py_CLEAR(clear_module_state->__pyx_n_s_includeNodesel); + Py_CLEAR(clear_module_state->__pyx_n_s_includePresol); + Py_CLEAR(clear_module_state->__pyx_n_s_includePricer); + Py_CLEAR(clear_module_state->__pyx_n_s_includeProp); + Py_CLEAR(clear_module_state->__pyx_n_s_includeReader); + Py_CLEAR(clear_module_state->__pyx_n_s_includeRelax); + Py_CLEAR(clear_module_state->__pyx_n_s_includeSepa); + Py_CLEAR(clear_module_state->__pyx_n_s_indices); + Py_CLEAR(clear_module_state->__pyx_n_s_inds); + Py_CLEAR(clear_module_state->__pyx_n_s_indvar); + Py_CLEAR(clear_module_state->__pyx_n_s_indvars); + Py_CLEAR(clear_module_state->__pyx_n_u_inf); + Py_CLEAR(clear_module_state->__pyx_n_s_infeasible); + Py_CLEAR(clear_module_state->__pyx_n_u_infeasible); + Py_CLEAR(clear_module_state->__pyx_n_s_infeasible_2); + Py_CLEAR(clear_module_state->__pyx_n_s_inferinfo); + Py_CLEAR(clear_module_state->__pyx_n_s_infinity); + Py_CLEAR(clear_module_state->__pyx_n_u_inforunbd); + Py_CLEAR(clear_module_state->__pyx_n_s_init); + Py_CLEAR(clear_module_state->__pyx_n_s_initBendersDefault); + Py_CLEAR(clear_module_state->__pyx_n_s_init_subclass); + Py_CLEAR(clear_module_state->__pyx_n_s_initial); + Py_CLEAR(clear_module_state->__pyx_n_u_initial); + Py_CLEAR(clear_module_state->__pyx_n_s_initializing); + Py_CLEAR(clear_module_state->__pyx_n_s_interruptSolve); + Py_CLEAR(clear_module_state->__pyx_n_s_intvars); + Py_CLEAR(clear_module_state->__pyx_n_s_isActive); + Py_CLEAR(clear_module_state->__pyx_n_s_isChecked); + Py_CLEAR(clear_module_state->__pyx_n_s_isCutEfficacious); + Py_CLEAR(clear_module_state->__pyx_n_s_isDualFeasible); + Py_CLEAR(clear_module_state->__pyx_n_s_isDynamic); + Py_CLEAR(clear_module_state->__pyx_n_s_isEQ); + Py_CLEAR(clear_module_state->__pyx_n_s_isEnforced); + Py_CLEAR(clear_module_state->__pyx_n_s_isFeasEQ); + Py_CLEAR(clear_module_state->__pyx_n_s_isFeasIntegral); + Py_CLEAR(clear_module_state->__pyx_n_s_isFeasNegative); + Py_CLEAR(clear_module_state->__pyx_n_s_isFeasZero); + Py_CLEAR(clear_module_state->__pyx_n_s_isGE); + Py_CLEAR(clear_module_state->__pyx_n_s_isGT); + Py_CLEAR(clear_module_state->__pyx_n_s_isInGlobalCutpool); + Py_CLEAR(clear_module_state->__pyx_n_s_isInLP); + Py_CLEAR(clear_module_state->__pyx_n_s_isInfinity); + Py_CLEAR(clear_module_state->__pyx_n_s_isInitial); + Py_CLEAR(clear_module_state->__pyx_n_s_isIntegral); + Py_CLEAR(clear_module_state->__pyx_n_s_isLE); + Py_CLEAR(clear_module_state->__pyx_n_s_isLPSolBasic); + Py_CLEAR(clear_module_state->__pyx_n_s_isLT); + Py_CLEAR(clear_module_state->__pyx_n_s_isLinear); + Py_CLEAR(clear_module_state->__pyx_n_s_isLocal); + Py_CLEAR(clear_module_state->__pyx_n_s_isModifiable); + Py_CLEAR(clear_module_state->__pyx_n_s_isNLPConstructed); + Py_CLEAR(clear_module_state->__pyx_n_s_isNonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_isObjChangedProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_isOriginal); + Py_CLEAR(clear_module_state->__pyx_n_s_isPrimalFeasible); + Py_CLEAR(clear_module_state->__pyx_n_s_isPropagated); + Py_CLEAR(clear_module_state->__pyx_n_s_isPropagatedAgain); + Py_CLEAR(clear_module_state->__pyx_n_s_isRedundant); + Py_CLEAR(clear_module_state->__pyx_n_s_isRemovable); + Py_CLEAR(clear_module_state->__pyx_n_s_isSeparated); + Py_CLEAR(clear_module_state->__pyx_n_s_isStickingAtNode); + Py_CLEAR(clear_module_state->__pyx_n_s_isZero); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_n_s_is_integer); + Py_CLEAR(clear_module_state->__pyx_n_s_is_memory_freed); + Py_CLEAR(clear_module_state->__pyx_n_s_is_number); + Py_CLEAR(clear_module_state->__pyx_n_s_isconvex); + Py_CLEAR(clear_module_state->__pyx_n_s_isdict); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_islpcut); + Py_CLEAR(clear_module_state->__pyx_n_s_isquadratic); + Py_CLEAR(clear_module_state->__pyx_n_s_items); + Py_CLEAR(clear_module_state->__pyx_n_s_iters); + Py_CLEAR(clear_module_state->__pyx_n_s_itertools); + Py_CLEAR(clear_module_state->__pyx_n_s_itlim); + Py_CLEAR(clear_module_state->__pyx_n_s_j); + Py_CLEAR(clear_module_state->__pyx_n_s_key); + Py_CLEAR(clear_module_state->__pyx_n_s_keys); + Py_CLEAR(clear_module_state->__pyx_n_s_kwargs); + Py_CLEAR(clear_module_state->__pyx_n_s_lambda); + Py_CLEAR(clear_module_state->__pyx_n_s_lastcol); + Py_CLEAR(clear_module_state->__pyx_n_s_lastrow); + Py_CLEAR(clear_module_state->__pyx_n_s_lb); + Py_CLEAR(clear_module_state->__pyx_n_s_lbs); + Py_CLEAR(clear_module_state->__pyx_n_s_leaves); + Py_CLEAR(clear_module_state->__pyx_n_s_leaves_2); + Py_CLEAR(clear_module_state->__pyx_n_s_len); + Py_CLEAR(clear_module_state->__pyx_n_s_length); + Py_CLEAR(clear_module_state->__pyx_n_s_lhs); + Py_CLEAR(clear_module_state->__pyx_n_u_lhs); + Py_CLEAR(clear_module_state->__pyx_n_s_lhs_2); + Py_CLEAR(clear_module_state->__pyx_n_s_lhss); + Py_CLEAR(clear_module_state->__pyx_n_s_lhsslack); + Py_CLEAR(clear_module_state->__pyx_n_s_lincoef); + Py_CLEAR(clear_module_state->__pyx_n_s_lincoefs); + Py_CLEAR(clear_module_state->__pyx_n_s_lincoefs_2); + Py_CLEAR(clear_module_state->__pyx_n_s_lincons); + Py_CLEAR(clear_module_state->__pyx_n_u_linear); + Py_CLEAR(clear_module_state->__pyx_n_s_linexprs); + Py_CLEAR(clear_module_state->__pyx_kp_u_linked_SCIP_is_not_compatible_to); + Py_CLEAR(clear_module_state->__pyx_kp_u_linked_SCIP_is_not_recommended_f); + Py_CLEAR(clear_module_state->__pyx_n_s_linterms); + Py_CLEAR(clear_module_state->__pyx_n_s_linvars); + Py_CLEAR(clear_module_state->__pyx_n_s_local); + Py_CLEAR(clear_module_state->__pyx_n_u_local); + Py_CLEAR(clear_module_state->__pyx_n_s_locale); + Py_CLEAR(clear_module_state->__pyx_n_s_locktype); + Py_CLEAR(clear_module_state->__pyx_n_s_log); + Py_CLEAR(clear_module_state->__pyx_n_u_log); + Py_CLEAR(clear_module_state->__pyx_n_u_lower); + Py_CLEAR(clear_module_state->__pyx_n_u_lowerbound); + Py_CLEAR(clear_module_state->__pyx_n_s_lowerbounds); + Py_CLEAR(clear_module_state->__pyx_n_s_lpcands); + Py_CLEAR(clear_module_state->__pyx_n_s_lpcandsfrac); + Py_CLEAR(clear_module_state->__pyx_n_s_lpcandssol); + Py_CLEAR(clear_module_state->__pyx_n_s_lperror); + Py_CLEAR(clear_module_state->__pyx_n_s_lpi); + Py_CLEAR(clear_module_state->__pyx_n_s_lpiGetIterations); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_map); + Py_CLEAR(clear_module_state->__pyx_n_s_mappedvar); + Py_CLEAR(clear_module_state->__pyx_n_u_mappedvar); + Py_CLEAR(clear_module_state->__pyx_n_s_mappedvar_2); + Py_CLEAR(clear_module_state->__pyx_n_s_max); + Py_CLEAR(clear_module_state->__pyx_n_s_maxactivity); + Py_CLEAR(clear_module_state->__pyx_n_s_maxbounddist); + Py_CLEAR(clear_module_state->__pyx_n_s_maxdepth); + Py_CLEAR(clear_module_state->__pyx_n_u_maximize); + Py_CLEAR(clear_module_state->__pyx_n_s_maxnconss); + Py_CLEAR(clear_module_state->__pyx_n_s_maxnselectedcuts); + Py_CLEAR(clear_module_state->__pyx_n_s_maxprerounds); + Py_CLEAR(clear_module_state->__pyx_n_s_maxproprounds); + Py_CLEAR(clear_module_state->__pyx_n_s_maxrounds); + Py_CLEAR(clear_module_state->__pyx_n_u_memlimit); + Py_CLEAR(clear_module_state->__pyx_n_s_memsavepriority); + Py_CLEAR(clear_module_state->__pyx_n_s_mergecandidates); + Py_CLEAR(clear_module_state->__pyx_n_u_merged); + Py_CLEAR(clear_module_state->__pyx_n_s_metaclass); + Py_CLEAR(clear_module_state->__pyx_n_s_method); + Py_CLEAR(clear_module_state->__pyx_kp_u_method_can_only_be_called_in_sta); + Py_CLEAR(clear_module_state->__pyx_kp_u_method_cannot_be_called_before_p); + Py_CLEAR(clear_module_state->__pyx_kp_u_method_cannot_be_called_for_cons); + Py_CLEAR(clear_module_state->__pyx_n_s_minactivity); + Py_CLEAR(clear_module_state->__pyx_n_u_minimize); + Py_CLEAR(clear_module_state->__pyx_n_s_minus); + Py_CLEAR(clear_module_state->__pyx_n_s_model); + Py_CLEAR(clear_module_state->__pyx_n_u_model); + Py_CLEAR(clear_module_state->__pyx_kp_u_model_cip); + Py_CLEAR(clear_module_state->__pyx_kp_u_model_getDualMultiplier_cons_is); + Py_CLEAR(clear_module_state->__pyx_n_s_modifiable); + Py_CLEAR(clear_module_state->__pyx_n_u_modifiable); + Py_CLEAR(clear_module_state->__pyx_n_s_module); + Py_CLEAR(clear_module_state->__pyx_n_s_monomials); + Py_CLEAR(clear_module_state->__pyx_n_s_mul); + Py_CLEAR(clear_module_state->__pyx_n_s_mul_2); + Py_CLEAR(clear_module_state->__pyx_n_s_myMessageHandler); + Py_CLEAR(clear_module_state->__pyx_n_s_n); + Py_CLEAR(clear_module_state->__pyx_n_s_n_conss); + Py_CLEAR(clear_module_state->__pyx_n_u_naddconss); + Py_CLEAR(clear_module_state->__pyx_n_u_naddholes); + Py_CLEAR(clear_module_state->__pyx_n_u_naggrvars); + Py_CLEAR(clear_module_state->__pyx_n_s_nam); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_u_name); + Py_CLEAR(clear_module_state->__pyx_n_s_name_2); + Py_CLEAR(clear_module_state->__pyx_n_s_nbenders); + Py_CLEAR(clear_module_state->__pyx_n_s_nbilinterms); + Py_CLEAR(clear_module_state->__pyx_n_s_nboundchgs); + Py_CLEAR(clear_module_state->__pyx_n_s_nbranchings); + Py_CLEAR(clear_module_state->__pyx_n_s_nbranchvars); + Py_CLEAR(clear_module_state->__pyx_n_s_ncands); + Py_CLEAR(clear_module_state->__pyx_n_u_nchgbds); + Py_CLEAR(clear_module_state->__pyx_n_u_nchgcoefs); + Py_CLEAR(clear_module_state->__pyx_n_u_nchgsides); + Py_CLEAR(clear_module_state->__pyx_n_u_nchgvartypes); + Py_CLEAR(clear_module_state->__pyx_n_s_nchildren); + Py_CLEAR(clear_module_state->__pyx_n_s_nchildren_2); + Py_CLEAR(clear_module_state->__pyx_n_s_ncols); + Py_CLEAR(clear_module_state->__pyx_n_s_nconsprop); + Py_CLEAR(clear_module_state->__pyx_n_s_nconss); + Py_CLEAR(clear_module_state->__pyx_n_s_nconss_2); + Py_CLEAR(clear_module_state->__pyx_n_u_ndelconss); + Py_CLEAR(clear_module_state->__pyx_n_s_ndomredsfound); + Py_CLEAR(clear_module_state->__pyx_n_s_needscons); + Py_CLEAR(clear_module_state->__pyx_n_s_negate); + Py_CLEAR(clear_module_state->__pyx_n_s_new); + Py_CLEAR(clear_module_state->__pyx_n_s_newCheck); + Py_CLEAR(clear_module_state->__pyx_n_s_newEnf); + Py_CLEAR(clear_module_state->__pyx_n_s_newInit); + Py_CLEAR(clear_module_state->__pyx_n_s_newProbingNode); + Py_CLEAR(clear_module_state->__pyx_n_s_newRem); + Py_CLEAR(clear_module_state->__pyx_n_s_newbound); + Py_CLEAR(clear_module_state->__pyx_n_s_newlhs); + Py_CLEAR(clear_module_state->__pyx_n_s_newobj); + Py_CLEAR(clear_module_state->__pyx_n_s_newrhs); + Py_CLEAR(clear_module_state->__pyx_n_s_newval); + Py_CLEAR(clear_module_state->__pyx_n_u_nfixedvars); + Py_CLEAR(clear_module_state->__pyx_n_s_nfracimplvars); + Py_CLEAR(clear_module_state->__pyx_n_s_niters); + Py_CLEAR(clear_module_state->__pyx_n_s_nleaves); + Py_CLEAR(clear_module_state->__pyx_n_s_nlinvars); + Py_CLEAR(clear_module_state->__pyx_n_s_nlinvars_2); + Py_CLEAR(clear_module_state->__pyx_n_s_nlocksdown); + Py_CLEAR(clear_module_state->__pyx_n_s_nlocksneg); + Py_CLEAR(clear_module_state->__pyx_n_s_nlockspos); + Py_CLEAR(clear_module_state->__pyx_n_s_nlocksup); + Py_CLEAR(clear_module_state->__pyx_n_s_nlpcands); + Py_CLEAR(clear_module_state->__pyx_n_s_nlrow); + Py_CLEAR(clear_module_state->__pyx_n_s_nlrows); + Py_CLEAR(clear_module_state->__pyx_n_s_nmarkedconss); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewaddconss); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewaddconss); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewaddholes); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewaggrvars); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewaggrvars); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewchgbds); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewchgbds); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewchgcoefs); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewchgcoefs); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewchgsides); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewchgsides); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewchgvartypes); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewchgvartypes); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewdelconss); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewdelconss); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewfixedvars); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewfixedvars); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewholes); + Py_CLEAR(clear_module_state->__pyx_n_s_nnewupgdconss); + Py_CLEAR(clear_module_state->__pyx_n_u_nnewupgdconss); + Py_CLEAR(clear_module_state->__pyx_n_s_nnonz); + Py_CLEAR(clear_module_state->__pyx_kp_u_no_reduced_cost_available_for_va); + Py_CLEAR(clear_module_state->__pyx_n_s_node); + Py_CLEAR(clear_module_state->__pyx_n_s_node1); + Py_CLEAR(clear_module_state->__pyx_n_s_node2); + Py_CLEAR(clear_module_state->__pyx_n_s_nodecomp); + Py_CLEAR(clear_module_state->__pyx_n_s_nodeexit); + Py_CLEAR(clear_module_state->__pyx_n_s_nodeexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_nodefree); + Py_CLEAR(clear_module_state->__pyx_n_s_nodeinfeasible); + Py_CLEAR(clear_module_state->__pyx_n_s_nodeinit); + Py_CLEAR(clear_module_state->__pyx_n_s_nodeinitsol); + Py_CLEAR(clear_module_state->__pyx_n_u_nodelimit); + Py_CLEAR(clear_module_state->__pyx_n_s_nodes); + Py_CLEAR(clear_module_state->__pyx_n_s_nodesel); + Py_CLEAR(clear_module_state->__pyx_n_s_nodeselect); + Py_CLEAR(clear_module_state->__pyx_n_s_nodeselprio); + Py_CLEAR(clear_module_state->__pyx_n_u_nonlinear); + Py_CLEAR(clear_module_state->__pyx_n_s_normalize); + Py_CLEAR(clear_module_state->__pyx_n_s_npriolpcands); + Py_CLEAR(clear_module_state->__pyx_n_s_npriomergecands); + Py_CLEAR(clear_module_state->__pyx_n_s_npriopseudocands); + Py_CLEAR(clear_module_state->__pyx_n_s_nprop); + Py_CLEAR(clear_module_state->__pyx_n_s_npseudocands); + Py_CLEAR(clear_module_state->__pyx_n_s_nquadterms); + Py_CLEAR(clear_module_state->__pyx_n_s_nrounds); + Py_CLEAR(clear_module_state->__pyx_n_s_nrows); + Py_CLEAR(clear_module_state->__pyx_n_u_nselectedcuts); + Py_CLEAR(clear_module_state->__pyx_n_s_nsiblings); + Py_CLEAR(clear_module_state->__pyx_n_s_nsols); + Py_CLEAR(clear_module_state->__pyx_n_s_nsubproblems); + Py_CLEAR(clear_module_state->__pyx_n_s_number); + Py_CLEAR(clear_module_state->__pyx_n_u_nupgdconss); + Py_CLEAR(clear_module_state->__pyx_n_s_nusefulconss); + Py_CLEAR(clear_module_state->__pyx_n_s_nvars); + Py_CLEAR(clear_module_state->__pyx_n_u_nvars); + Py_CLEAR(clear_module_state->__pyx_n_s_nvars_2); + Py_CLEAR(clear_module_state->__pyx_n_s_obj); + Py_CLEAR(clear_module_state->__pyx_n_s_objective); + Py_CLEAR(clear_module_state->__pyx_n_u_objective); + Py_CLEAR(clear_module_state->__pyx_n_s_objinfeasible); + Py_CLEAR(clear_module_state->__pyx_n_s_objlimit); + Py_CLEAR(clear_module_state->__pyx_n_s_objoffset); + Py_CLEAR(clear_module_state->__pyx_n_s_objs); + Py_CLEAR(clear_module_state->__pyx_n_s_objscale); + Py_CLEAR(clear_module_state->__pyx_n_s_objsense); + Py_CLEAR(clear_module_state->__pyx_n_s_objval); + Py_CLEAR(clear_module_state->__pyx_n_s_offset); + Py_CLEAR(clear_module_state->__pyx_n_s_onlychanged); + Py_CLEAR(clear_module_state->__pyx_n_s_onlyconvex); + Py_CLEAR(clear_module_state->__pyx_n_s_onlydelayed); + Py_CLEAR(clear_module_state->__pyx_n_s_onlyroot); + Py_CLEAR(clear_module_state->__pyx_n_s_op); + Py_CLEAR(clear_module_state->__pyx_n_s_op_2); + Py_CLEAR(clear_module_state->__pyx_n_s_open); + Py_CLEAR(clear_module_state->__pyx_n_s_opidx); + Py_CLEAR(clear_module_state->__pyx_n_s_optimal); + Py_CLEAR(clear_module_state->__pyx_n_u_optimal); + Py_CLEAR(clear_module_state->__pyx_n_s_optimize); + Py_CLEAR(clear_module_state->__pyx_n_s_origcopy); + Py_CLEAR(clear_module_state->__pyx_n_s_original); + Py_CLEAR(clear_module_state->__pyx_kp_u_origprob_sol); + Py_CLEAR(clear_module_state->__pyx_kp_u_origprob_stats); + Py_CLEAR(clear_module_state->__pyx_n_s_orthofunc); + Py_CLEAR(clear_module_state->__pyx_n_s_os); + Py_CLEAR(clear_module_state->__pyx_n_s_os_path); + Py_CLEAR(clear_module_state->__pyx_n_s_other); + Py_CLEAR(clear_module_state->__pyx_n_s_paraemphasis); + Py_CLEAR(clear_module_state->__pyx_n_s_param); + Py_CLEAR(clear_module_state->__pyx_kp_u_param_set); + Py_CLEAR(clear_module_state->__pyx_n_s_params); + Py_CLEAR(clear_module_state->__pyx_n_s_paramtype); + Py_CLEAR(clear_module_state->__pyx_n_s_partial); + Py_CLEAR(clear_module_state->__pyx_n_s_partialsolution); + Py_CLEAR(clear_module_state->__pyx_n_s_path); + Py_CLEAR(clear_module_state->__pyx_n_s_pickle); + Py_CLEAR(clear_module_state->__pyx_n_s_plus); + Py_CLEAR(clear_module_state->__pyx_n_s_pos); + Py_CLEAR(clear_module_state->__pyx_n_s_power); + Py_CLEAR(clear_module_state->__pyx_n_s_prepare); + Py_CLEAR(clear_module_state->__pyx_n_s_presol); + Py_CLEAR(clear_module_state->__pyx_n_s_presolexec); + Py_CLEAR(clear_module_state->__pyx_n_s_presolexit); + Py_CLEAR(clear_module_state->__pyx_n_s_presolexitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_presolfree); + Py_CLEAR(clear_module_state->__pyx_n_s_presolinit); + Py_CLEAR(clear_module_state->__pyx_n_s_presolinitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_presolmaxrounds); + Py_CLEAR(clear_module_state->__pyx_n_s_presolpriority); + Py_CLEAR(clear_module_state->__pyx_n_s_presoltiming); + Py_CLEAR(clear_module_state->__pyx_n_s_presolve); + Py_CLEAR(clear_module_state->__pyx_n_s_pretendroot); + Py_CLEAR(clear_module_state->__pyx_n_s_pricedVar); + Py_CLEAR(clear_module_state->__pyx_n_s_pricedVarScore); + Py_CLEAR(clear_module_state->__pyx_n_s_pricer); + Py_CLEAR(clear_module_state->__pyx_n_s_pricerexit); + Py_CLEAR(clear_module_state->__pyx_n_s_pricerexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_pricerfarkas); + Py_CLEAR(clear_module_state->__pyx_kp_u_pricerfarkas_is_a_fundamental_ca); + Py_CLEAR(clear_module_state->__pyx_n_s_pricerfree); + Py_CLEAR(clear_module_state->__pyx_n_s_pricerinit); + Py_CLEAR(clear_module_state->__pyx_n_s_pricerinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_pricerredcost); + Py_CLEAR(clear_module_state->__pyx_kp_u_pricerredcost_is_a_fundamental_c); + Py_CLEAR(clear_module_state->__pyx_n_u_primallimit); + Py_CLEAR(clear_module_state->__pyx_n_s_primalsol); + Py_CLEAR(clear_module_state->__pyx_n_s_print); + Py_CLEAR(clear_module_state->__pyx_n_s_printBestSol); + Py_CLEAR(clear_module_state->__pyx_n_s_printCons); + Py_CLEAR(clear_module_state->__pyx_n_s_printExternalCodeVersions); + Py_CLEAR(clear_module_state->__pyx_n_s_printNlRow); + Py_CLEAR(clear_module_state->__pyx_n_s_printRow); + Py_CLEAR(clear_module_state->__pyx_n_s_printSol); + Py_CLEAR(clear_module_state->__pyx_n_s_printStatistics); + Py_CLEAR(clear_module_state->__pyx_n_s_printVersion); + Py_CLEAR(clear_module_state->__pyx_n_s_print_memory_in_use); + Py_CLEAR(clear_module_state->__pyx_n_s_printreason); + Py_CLEAR(clear_module_state->__pyx_n_s_priority); + Py_CLEAR(clear_module_state->__pyx_n_s_probingdepth); + Py_CLEAR(clear_module_state->__pyx_n_s_problemName); + Py_CLEAR(clear_module_state->__pyx_n_s_probnumber); + Py_CLEAR(clear_module_state->__pyx_n_s_prod); + Py_CLEAR(clear_module_state->__pyx_n_u_prod); + Py_CLEAR(clear_module_state->__pyx_n_s_prodexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_prop); + Py_CLEAR(clear_module_state->__pyx_n_s_propagate); + Py_CLEAR(clear_module_state->__pyx_n_u_propagate); + Py_CLEAR(clear_module_state->__pyx_n_s_propagateProbing); + Py_CLEAR(clear_module_state->__pyx_kp_u_propagating_maxrounds); + Py_CLEAR(clear_module_state->__pyx_kp_u_propagating_maxroundsroot); + Py_CLEAR(clear_module_state->__pyx_n_s_propexec); + Py_CLEAR(clear_module_state->__pyx_n_s_propexit); + Py_CLEAR(clear_module_state->__pyx_n_s_propexitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_propexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_propfree); + Py_CLEAR(clear_module_state->__pyx_n_s_propfreq); + Py_CLEAR(clear_module_state->__pyx_n_s_propinit); + Py_CLEAR(clear_module_state->__pyx_n_s_propinitpre); + Py_CLEAR(clear_module_state->__pyx_n_s_propinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_proppresol); + Py_CLEAR(clear_module_state->__pyx_n_s_propresprop); + Py_CLEAR(clear_module_state->__pyx_n_s_proptiming); + Py_CLEAR(clear_module_state->__pyx_n_s_proxy); + Py_CLEAR(clear_module_state->__pyx_n_s_pseudocands); + Py_CLEAR(clear_module_state->__pyx_n_s_ptr); + Py_CLEAR(clear_module_state->__pyx_n_s_ptrtuple); + Py_CLEAR(clear_module_state->__pyx_n_u_ptrtuple); + Py_CLEAR(clear_module_state->__pyx_n_s_pyCons); + Py_CLEAR(clear_module_state->__pyx_n_s_pyVar); + Py_CLEAR(clear_module_state->__pyx_n_s_py_boundtypes); + Py_CLEAR(clear_module_state->__pyx_n_s_py_branchbounds); + Py_CLEAR(clear_module_state->__pyx_n_s_py_variables); + Py_CLEAR(clear_module_state->__pyx_n_s_pycons); + Py_CLEAR(clear_module_state->__pyx_n_s_pycons_initial); + Py_CLEAR(clear_module_state->__pyx_n_s_pyscipopt_scip); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_benderscreatesub); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_benderscutexec_t); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_bendersgetvar_th); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_conscheck_this_m); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_consenfolp_this); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_consenfops_this); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_consenforelax_th); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_conslock_this_me); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_eventexec_this_m); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_heurexec_this_me); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_presolexec_this); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_propexec_this_me); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_propresprop_this); + Py_CLEAR(clear_module_state->__pyx_kp_u_python_error_in_relaxexec_this_m); + Py_CLEAR(clear_module_state->__pyx_n_s_pyvar); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Benderscut); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Branchrule); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Conshdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Constant); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Cutsel); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Eventhdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Expr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_ExprCons); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_GenExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Heur); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Nodesel); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_RESULT); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_STAGE); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_STATUS); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_PowExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Presol); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Pricer); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_ProdExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Prop); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Reader); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Relax); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_Sepa); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_SumExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_UnaryExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle_VarExpr); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); + Py_CLEAR(clear_module_state->__pyx_n_s_quadcons); + Py_CLEAR(clear_module_state->__pyx_n_u_quadratic); + Py_CLEAR(clear_module_state->__pyx_n_s_quadterms); + Py_CLEAR(clear_module_state->__pyx_n_s_quality); + Py_CLEAR(clear_module_state->__pyx_n_s_qualname); + Py_CLEAR(clear_module_state->__pyx_n_s_quickprod); + Py_CLEAR(clear_module_state->__pyx_n_s_quicksum); + Py_CLEAR(clear_module_state->__pyx_n_s_quiet); + Py_CLEAR(clear_module_state->__pyx_n_s_raise_error); + Py_CLEAR(clear_module_state->__pyx_n_s_range); + Py_CLEAR(clear_module_state->__pyx_n_s_ray); + Py_CLEAR(clear_module_state->__pyx_n_s_rc); + Py_CLEAR(clear_module_state->__pyx_n_s_readLP); + Py_CLEAR(clear_module_state->__pyx_n_s_readParams); + Py_CLEAR(clear_module_state->__pyx_n_s_readProblem); + Py_CLEAR(clear_module_state->__pyx_n_s_readSol); + Py_CLEAR(clear_module_state->__pyx_n_s_readSolFile); + Py_CLEAR(clear_module_state->__pyx_n_s_reader); + Py_CLEAR(clear_module_state->__pyx_n_s_readerfree); + Py_CLEAR(clear_module_state->__pyx_n_s_readerread); + Py_CLEAR(clear_module_state->__pyx_n_s_readerwrite); + Py_CLEAR(clear_module_state->__pyx_n_s_redcost); + Py_CLEAR(clear_module_state->__pyx_n_s_redirectOutput); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_relax); + Py_CLEAR(clear_module_state->__pyx_n_s_relaxcons); + Py_CLEAR(clear_module_state->__pyx_n_s_relaxedbd); + Py_CLEAR(clear_module_state->__pyx_n_s_relaxexec); + Py_CLEAR(clear_module_state->__pyx_kp_u_relaxexec_must_return_a_dictiona); + Py_CLEAR(clear_module_state->__pyx_n_s_relaxexit); + Py_CLEAR(clear_module_state->__pyx_n_s_relaxexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_relaxfree); + Py_CLEAR(clear_module_state->__pyx_n_s_relaxinit); + Py_CLEAR(clear_module_state->__pyx_n_s_relaxinitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_releaseRow); + Py_CLEAR(clear_module_state->__pyx_n_s_removable); + Py_CLEAR(clear_module_state->__pyx_n_u_removable); + Py_CLEAR(clear_module_state->__pyx_n_s_repeat); + Py_CLEAR(clear_module_state->__pyx_n_s_repr); + Py_CLEAR(clear_module_state->__pyx_n_s_repr___locals_lambda); + Py_CLEAR(clear_module_state->__pyx_n_s_repropagateNode); + Py_CLEAR(clear_module_state->__pyx_n_s_resVar); + Py_CLEAR(clear_module_state->__pyx_n_s_resetParam); + Py_CLEAR(clear_module_state->__pyx_n_s_resetParams); + Py_CLEAR(clear_module_state->__pyx_n_s_restart); + Py_CLEAR(clear_module_state->__pyx_n_s_restartSolve); + Py_CLEAR(clear_module_state->__pyx_n_u_restartlimit); + Py_CLEAR(clear_module_state->__pyx_n_s_result); + Py_CLEAR(clear_module_state->__pyx_n_u_result); + Py_CLEAR(clear_module_state->__pyx_n_s_result_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_resvar); + Py_CLEAR(clear_module_state->__pyx_n_s_retcode); + Py_CLEAR(clear_module_state->__pyx_n_s_rhs); + Py_CLEAR(clear_module_state->__pyx_n_u_rhs); + Py_CLEAR(clear_module_state->__pyx_n_s_rhs_2); + Py_CLEAR(clear_module_state->__pyx_n_s_rhss); + Py_CLEAR(clear_module_state->__pyx_n_s_rhsslack); + Py_CLEAR(clear_module_state->__pyx_n_s_rhsvar); + Py_CLEAR(clear_module_state->__pyx_n_s_root); + Py_CLEAR(clear_module_state->__pyx_n_s_row); + Py_CLEAR(clear_module_state->__pyx_n_u_row); + Py_CLEAR(clear_module_state->__pyx_n_s_row1); + Py_CLEAR(clear_module_state->__pyx_n_s_row2); + Py_CLEAR(clear_module_state->__pyx_n_s_rows); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_benders); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_benderscut); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_col); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_con); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_cons); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_conshdlr); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_expr); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_pricer); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_sepa); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_sol); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_subprob); + Py_CLEAR(clear_module_state->__pyx_n_s_scip_var); + Py_CLEAR(clear_module_state->__pyx_n_s_scipexprs); + Py_CLEAR(clear_module_state->__pyx_n_s_scipvar1); + Py_CLEAR(clear_module_state->__pyx_n_s_scipvar2); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_kp_s_self__benders_cannot_be_converte); + Py_CLEAR(clear_module_state->__pyx_kp_s_self__scip_self__valid_cannot_be); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_event_cannot_be_converted_t); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_lpi_cannot_be_converted_to); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_boundchg_cannot_be_con); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_col_cannot_be_converte); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_cons_cannot_be_convert); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_domchg_cannot_be_conve); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_nlrow_cannot_be_conver); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_node_cannot_be_convert); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_row_cannot_be_converte); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_self_sol_cannot_be_con); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_scip_var_cannot_be_converte); + Py_CLEAR(clear_module_state->__pyx_n_u_selnode); + Py_CLEAR(clear_module_state->__pyx_n_s_send); + Py_CLEAR(clear_module_state->__pyx_n_s_sense); + Py_CLEAR(clear_module_state->__pyx_n_s_sepa); + Py_CLEAR(clear_module_state->__pyx_n_s_sepaexeclp); + Py_CLEAR(clear_module_state->__pyx_n_s_sepaexecsol); + Py_CLEAR(clear_module_state->__pyx_n_s_sepaexit); + Py_CLEAR(clear_module_state->__pyx_n_s_sepaexitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_sepafree); + Py_CLEAR(clear_module_state->__pyx_n_s_sepafreq); + Py_CLEAR(clear_module_state->__pyx_n_s_sepainit); + Py_CLEAR(clear_module_state->__pyx_n_s_sepainitsol); + Py_CLEAR(clear_module_state->__pyx_n_s_sepapriority); + Py_CLEAR(clear_module_state->__pyx_n_s_separate); + Py_CLEAR(clear_module_state->__pyx_n_u_separate); + Py_CLEAR(clear_module_state->__pyx_n_s_separateSol); + Py_CLEAR(clear_module_state->__pyx_n_s_setBendersSubproblemIsConvex); + Py_CLEAR(clear_module_state->__pyx_n_s_setBoolParam); + Py_CLEAR(clear_module_state->__pyx_n_s_setCharParam); + Py_CLEAR(clear_module_state->__pyx_n_s_setCheck); + Py_CLEAR(clear_module_state->__pyx_n_s_setEmphasis); + Py_CLEAR(clear_module_state->__pyx_n_s_setEnforced); + Py_CLEAR(clear_module_state->__pyx_n_s_setHeuristics); + Py_CLEAR(clear_module_state->__pyx_n_s_setInitial); + Py_CLEAR(clear_module_state->__pyx_n_s_setIntParam); + Py_CLEAR(clear_module_state->__pyx_n_s_setLogfile); + Py_CLEAR(clear_module_state->__pyx_n_s_setLongintParam); + Py_CLEAR(clear_module_state->__pyx_n_s_setMaximize); + Py_CLEAR(clear_module_state->__pyx_n_s_setMinimize); + Py_CLEAR(clear_module_state->__pyx_n_s_setObjIntegral); + Py_CLEAR(clear_module_state->__pyx_n_s_setObjective); + Py_CLEAR(clear_module_state->__pyx_n_s_setObjlimit); + Py_CLEAR(clear_module_state->__pyx_n_s_setParam); + Py_CLEAR(clear_module_state->__pyx_n_s_setParams); + Py_CLEAR(clear_module_state->__pyx_n_s_setParamsCountsols); + Py_CLEAR(clear_module_state->__pyx_n_s_setPresolve); + Py_CLEAR(clear_module_state->__pyx_n_s_setProbName); + Py_CLEAR(clear_module_state->__pyx_n_s_setRealParam); + Py_CLEAR(clear_module_state->__pyx_n_s_setRelaxSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_setRemovable); + Py_CLEAR(clear_module_state->__pyx_n_s_setSeparating); + Py_CLEAR(clear_module_state->__pyx_n_s_setSolVal); + Py_CLEAR(clear_module_state->__pyx_n_s_setStringParam); + Py_CLEAR(clear_module_state->__pyx_n_s_set_name); + Py_CLEAR(clear_module_state->__pyx_n_s_setlocale); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_setting); + Py_CLEAR(clear_module_state->__pyx_n_s_setupBendersSubproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_shareaux); + Py_CLEAR(clear_module_state->__pyx_n_s_siblings); + Py_CLEAR(clear_module_state->__pyx_n_s_siblings_2); + Py_CLEAR(clear_module_state->__pyx_n_s_side); + Py_CLEAR(clear_module_state->__pyx_n_s_sin); + Py_CLEAR(clear_module_state->__pyx_n_u_sin); + Py_CLEAR(clear_module_state->__pyx_n_u_skipsolve); + Py_CLEAR(clear_module_state->__pyx_n_s_slots); + Py_CLEAR(clear_module_state->__pyx_n_s_sol); + Py_CLEAR(clear_module_state->__pyx_n_s_sol_2); + Py_CLEAR(clear_module_state->__pyx_n_s_solinfeasible); + Py_CLEAR(clear_module_state->__pyx_n_u_sollimit); + Py_CLEAR(clear_module_state->__pyx_n_s_solptr); + Py_CLEAR(clear_module_state->__pyx_n_s_sols); + Py_CLEAR(clear_module_state->__pyx_n_s_sols_2); + Py_CLEAR(clear_module_state->__pyx_n_s_solution); + Py_CLEAR(clear_module_state->__pyx_n_s_solutions); + Py_CLEAR(clear_module_state->__pyx_n_s_solve); + Py_CLEAR(clear_module_state->__pyx_n_s_solveBendersSubproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_solveConcurrent); + Py_CLEAR(clear_module_state->__pyx_n_s_solveDiveLP); + Py_CLEAR(clear_module_state->__pyx_n_s_solveProbingLP); + Py_CLEAR(clear_module_state->__pyx_n_s_solvecip); + Py_CLEAR(clear_module_state->__pyx_n_s_sorted); + Py_CLEAR(clear_module_state->__pyx_n_s_sourceModel); + Py_CLEAR(clear_module_state->__pyx_n_s_sourceconstraint); + Py_CLEAR(clear_module_state->__pyx_n_s_spec); + Py_CLEAR(clear_module_state->__pyx_n_s_splitext); + Py_CLEAR(clear_module_state->__pyx_n_s_sqrcoef); + Py_CLEAR(clear_module_state->__pyx_n_s_sqrexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_sqrt); + Py_CLEAR(clear_module_state->__pyx_n_u_sqrt); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_benders_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_benderscut_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_branchrule_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_conshdlr_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_cutsel_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_event_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_expr_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_heuristic_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_lp_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_nodesel_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_presol_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_pricer_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_propagator_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_reader_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_relax_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_scip_pxi); + Py_CLEAR(clear_module_state->__pyx_kp_s_src_pyscipopt_sepa_pxi); + Py_CLEAR(clear_module_state->__pyx_n_u_stallnodelimit); + Py_CLEAR(clear_module_state->__pyx_n_s_startDive); + Py_CLEAR(clear_module_state->__pyx_n_s_startProbing); + Py_CLEAR(clear_module_state->__pyx_n_s_startnconss); + Py_CLEAR(clear_module_state->__pyx_n_s_startnvars); + Py_CLEAR(clear_module_state->__pyx_n_s_stat); + Py_CLEAR(clear_module_state->__pyx_n_s_state); + Py_CLEAR(clear_module_state->__pyx_n_s_staticmethod); + Py_CLEAR(clear_module_state->__pyx_n_s_stderr); + Py_CLEAR(clear_module_state->__pyx_n_s_stdout); + Py_CLEAR(clear_module_state->__pyx_n_s_stdpriority); + Py_CLEAR(clear_module_state->__pyx_n_s_stickingatnode); + Py_CLEAR(clear_module_state->__pyx_n_u_stickingatnode); + Py_CLEAR(clear_module_state->__pyx_n_u_stopearly); + Py_CLEAR(clear_module_state->__pyx_n_s_stored); + Py_CLEAR(clear_module_state->__pyx_n_s_str_absfile); + Py_CLEAR(clear_module_state->__pyx_n_s_str_conversion); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_subprob); + Py_CLEAR(clear_module_state->__pyx_n_s_subproblem); + Py_CLEAR(clear_module_state->__pyx_n_s_subproblems); + Py_CLEAR(clear_module_state->__pyx_n_s_subprobs); + Py_CLEAR(clear_module_state->__pyx_n_s_success); + Py_CLEAR(clear_module_state->__pyx_n_u_success); + Py_CLEAR(clear_module_state->__pyx_n_s_sum); + Py_CLEAR(clear_module_state->__pyx_n_u_sum); + Py_CLEAR(clear_module_state->__pyx_n_s_sumexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_super); + Py_CLEAR(clear_module_state->__pyx_n_s_sys); + Py_CLEAR(clear_module_state->__pyx_n_s_t); + Py_CLEAR(clear_module_state->__pyx_n_s_take_ownership); + Py_CLEAR(clear_module_state->__pyx_n_u_targetcons); + Py_CLEAR(clear_module_state->__pyx_n_s_targetvalue); + Py_CLEAR(clear_module_state->__pyx_n_s_temp_cons); + Py_CLEAR(clear_module_state->__pyx_n_s_term); + Py_CLEAR(clear_module_state->__pyx_kp_u_term_length_must_be_1_or_2_but_i); + Py_CLEAR(clear_module_state->__pyx_n_s_termcoefs); + Py_CLEAR(clear_module_state->__pyx_n_s_termidx); + Py_CLEAR(clear_module_state->__pyx_n_s_termlist); + Py_CLEAR(clear_module_state->__pyx_n_s_terms); + Py_CLEAR(clear_module_state->__pyx_n_s_termvars); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_threadsafe); + Py_CLEAR(clear_module_state->__pyx_n_s_throw); + Py_CLEAR(clear_module_state->__pyx_n_s_tightenVarLb); + Py_CLEAR(clear_module_state->__pyx_n_s_tightenVarLbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_tightenVarUb); + Py_CLEAR(clear_module_state->__pyx_n_s_tightenVarUbGlobal); + Py_CLEAR(clear_module_state->__pyx_n_s_tightened); + Py_CLEAR(clear_module_state->__pyx_n_u_timelimit); + Py_CLEAR(clear_module_state->__pyx_n_s_timing); + Py_CLEAR(clear_module_state->__pyx_n_s_timingmask); + Py_CLEAR(clear_module_state->__pyx_n_s_tmp); + Py_CLEAR(clear_module_state->__pyx_n_s_to_ptr); + Py_CLEAR(clear_module_state->__pyx_kp_u_total_number_of_solutions_found); + Py_CLEAR(clear_module_state->__pyx_n_u_totalnodelimit); + Py_CLEAR(clear_module_state->__pyx_n_s_trans); + Py_CLEAR(clear_module_state->__pyx_n_s_transcons); + Py_CLEAR(clear_module_state->__pyx_n_s_transformed); + Py_CLEAR(clear_module_state->__pyx_kp_u_transprob_sol); + Py_CLEAR(clear_module_state->__pyx_n_u_true); + Py_CLEAR(clear_module_state->__pyx_n_s_truediv); + Py_CLEAR(clear_module_state->__pyx_n_s_trySol); + Py_CLEAR(clear_module_state->__pyx_n_s_tvar); + Py_CLEAR(clear_module_state->__pyx_n_s_typing); + Py_CLEAR(clear_module_state->__pyx_n_s_ub); + Py_CLEAR(clear_module_state->__pyx_n_s_ubs); + Py_CLEAR(clear_module_state->__pyx_n_u_unbounded); + Py_CLEAR(clear_module_state->__pyx_n_u_unknown); + Py_CLEAR(clear_module_state->__pyx_kp_u_unrecognized_objective_sense); + Py_CLEAR(clear_module_state->__pyx_kp_u_unrecognized_optimization_sense); + Py_CLEAR(clear_module_state->__pyx_kp_u_unrecognized_variable_type); + Py_CLEAR(clear_module_state->__pyx_n_s_upchild); + Py_CLEAR(clear_module_state->__pyx_n_s_update); + Py_CLEAR(clear_module_state->__pyx_n_s_updateBendersLowerbounds); + Py_CLEAR(clear_module_state->__pyx_n_s_updateNodeLowerbound); + Py_CLEAR(clear_module_state->__pyx_n_s_upper); + Py_CLEAR(clear_module_state->__pyx_n_u_upper); + Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_user_locale); + Py_CLEAR(clear_module_state->__pyx_n_u_userinterrupt); + Py_CLEAR(clear_module_state->__pyx_n_s_usessubscip); + Py_CLEAR(clear_module_state->__pyx_kp_u_utf_8); + Py_CLEAR(clear_module_state->__pyx_n_s_v); + Py_CLEAR(clear_module_state->__pyx_n_s_val); + Py_CLEAR(clear_module_state->__pyx_n_s_val1); + Py_CLEAR(clear_module_state->__pyx_n_s_val2); + Py_CLEAR(clear_module_state->__pyx_n_s_valid); + Py_CLEAR(clear_module_state->__pyx_n_s_validnode); + Py_CLEAR(clear_module_state->__pyx_n_s_vals); + Py_CLEAR(clear_module_state->__pyx_n_s_vals_2); + Py_CLEAR(clear_module_state->__pyx_n_s_valsdict); + Py_CLEAR(clear_module_state->__pyx_n_s_value); + Py_CLEAR(clear_module_state->__pyx_n_s_value_to_array); + Py_CLEAR(clear_module_state->__pyx_n_s_valuenode); + Py_CLEAR(clear_module_state->__pyx_n_s_values); + Py_CLEAR(clear_module_state->__pyx_n_s_var); + Py_CLEAR(clear_module_state->__pyx_n_u_var); + Py_CLEAR(clear_module_state->__pyx_n_s_var1); + Py_CLEAR(clear_module_state->__pyx_n_s_var2); + Py_CLEAR(clear_module_state->__pyx_n_s_var_2); + Py_CLEAR(clear_module_state->__pyx_n_s_var_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_varexpr); + Py_CLEAR(clear_module_state->__pyx_n_s_varexprs); + Py_CLEAR(clear_module_state->__pyx_n_s_variable); + Py_CLEAR(clear_module_state->__pyx_n_s_variables); + Py_CLEAR(clear_module_state->__pyx_n_s_varidx); + Py_CLEAR(clear_module_state->__pyx_n_s_varindex); + Py_CLEAR(clear_module_state->__pyx_n_s_varpos); + Py_CLEAR(clear_module_state->__pyx_n_s_vars); + Py_CLEAR(clear_module_state->__pyx_n_s_vars_2); + Py_CLEAR(clear_module_state->__pyx_n_s_vars_array); + Py_CLEAR(clear_module_state->__pyx_n_s_vartuple); + Py_CLEAR(clear_module_state->__pyx_n_u_vartuple); + Py_CLEAR(clear_module_state->__pyx_n_s_vartype); + Py_CLEAR(clear_module_state->__pyx_n_s_verbose); + Py_CLEAR(clear_module_state->__pyx_n_s_version); + Py_CLEAR(clear_module_state->__pyx_n_s_version_info); + Py_CLEAR(clear_module_state->__pyx_n_s_vtype); + Py_CLEAR(clear_module_state->__pyx_n_u_w); + Py_CLEAR(clear_module_state->__pyx_n_s_warn); + Py_CLEAR(clear_module_state->__pyx_n_s_warnings); + Py_CLEAR(clear_module_state->__pyx_n_s_weakref); + Py_CLEAR(clear_module_state->__pyx_n_s_weight); + Py_CLEAR(clear_module_state->__pyx_n_s_weights); + Py_CLEAR(clear_module_state->__pyx_n_s_write); + Py_CLEAR(clear_module_state->__pyx_n_s_writeBestSol); + Py_CLEAR(clear_module_state->__pyx_n_s_writeBestTransSol); + Py_CLEAR(clear_module_state->__pyx_n_s_writeLP); + Py_CLEAR(clear_module_state->__pyx_n_s_writeName); + Py_CLEAR(clear_module_state->__pyx_n_s_writeParams); + Py_CLEAR(clear_module_state->__pyx_n_s_writeProblem); + Py_CLEAR(clear_module_state->__pyx_n_s_writeSol); + Py_CLEAR(clear_module_state->__pyx_n_s_writeStatistics); + Py_CLEAR(clear_module_state->__pyx_n_s_writeTransSol); + Py_CLEAR(clear_module_state->__pyx_n_s_write_zeros); + Py_CLEAR(clear_module_state->__pyx_kp_u_wrote_parameter_settings_to_file); + Py_CLEAR(clear_module_state->__pyx_kp_u_wrote_problem_to_file); + Py_CLEAR(clear_module_state->__pyx_n_s_x); + Py_CLEAR(clear_module_state->__pyx_n_u_x); + Py_CLEAR(clear_module_state->__pyx_n_u_zero); + Py_CLEAR(clear_module_state->__pyx_float_0_0); + Py_CLEAR(clear_module_state->__pyx_float_1_0); + Py_CLEAR(clear_module_state->__pyx_float_10_0); + Py_CLEAR(clear_module_state->__pyx_float_100_0); + Py_CLEAR(clear_module_state->__pyx_float_1e_20); + Py_CLEAR(clear_module_state->__pyx_float_neg_1_0); + Py_CLEAR(clear_module_state->__pyx_int_0); + Py_CLEAR(clear_module_state->__pyx_int_1); + Py_CLEAR(clear_module_state->__pyx_int_2); + Py_CLEAR(clear_module_state->__pyx_int_3); + Py_CLEAR(clear_module_state->__pyx_int_5); + Py_CLEAR(clear_module_state->__pyx_int_9); + Py_CLEAR(clear_module_state->__pyx_int_10); + Py_CLEAR(clear_module_state->__pyx_int_100); + Py_CLEAR(clear_module_state->__pyx_int_101); + Py_CLEAR(clear_module_state->__pyx_int_10000); + Py_CLEAR(clear_module_state->__pyx_int_13758880); + Py_CLEAR(clear_module_state->__pyx_int_25280761); + Py_CLEAR(clear_module_state->__pyx_int_30435853); + Py_CLEAR(clear_module_state->__pyx_int_34551270); + Py_CLEAR(clear_module_state->__pyx_int_37557029); + Py_CLEAR(clear_module_state->__pyx_int_63254455); + Py_CLEAR(clear_module_state->__pyx_int_76513566); + Py_CLEAR(clear_module_state->__pyx_int_76998962); + Py_CLEAR(clear_module_state->__pyx_int_80720285); + Py_CLEAR(clear_module_state->__pyx_int_85795681); + Py_CLEAR(clear_module_state->__pyx_int_95355963); + Py_CLEAR(clear_module_state->__pyx_int_114651189); + Py_CLEAR(clear_module_state->__pyx_int_116691903); + Py_CLEAR(clear_module_state->__pyx_int_132603380); + Py_CLEAR(clear_module_state->__pyx_int_135158539); + Py_CLEAR(clear_module_state->__pyx_int_143015212); + Py_CLEAR(clear_module_state->__pyx_int_147635180); + Py_CLEAR(clear_module_state->__pyx_int_150239579); + Py_CLEAR(clear_module_state->__pyx_int_152146234); + Py_CLEAR(clear_module_state->__pyx_int_154610759); + Py_CLEAR(clear_module_state->__pyx_int_169888372); + Py_CLEAR(clear_module_state->__pyx_int_173957064); + Py_CLEAR(clear_module_state->__pyx_int_176834982); + Py_CLEAR(clear_module_state->__pyx_int_201230365); + Py_CLEAR(clear_module_state->__pyx_int_204489503); + Py_CLEAR(clear_module_state->__pyx_int_208012509); + Py_CLEAR(clear_module_state->__pyx_int_208195651); + Py_CLEAR(clear_module_state->__pyx_int_214626690); + Py_CLEAR(clear_module_state->__pyx_int_216408278); + Py_CLEAR(clear_module_state->__pyx_int_222419149); + Py_CLEAR(clear_module_state->__pyx_int_228825662); + Py_CLEAR(clear_module_state->__pyx_int_238750788); + Py_CLEAR(clear_module_state->__pyx_int_240430858); + Py_CLEAR(clear_module_state->__pyx_int_248330301); + Py_CLEAR(clear_module_state->__pyx_int_253686829); + Py_CLEAR(clear_module_state->__pyx_int_267356384); + Py_CLEAR(clear_module_state->__pyx_int_neg_1); + Py_CLEAR(clear_module_state->__pyx_k__101); + Py_CLEAR(clear_module_state->__pyx_k__102); + Py_CLEAR(clear_module_state->__pyx_k__103); + Py_CLEAR(clear_module_state->__pyx_k__104); + Py_CLEAR(clear_module_state->__pyx_k__105); + Py_CLEAR(clear_module_state->__pyx_k__106); + Py_CLEAR(clear_module_state->__pyx_tuple_); + Py_CLEAR(clear_module_state->__pyx_tuple__3); + Py_CLEAR(clear_module_state->__pyx_tuple__4); + Py_CLEAR(clear_module_state->__pyx_tuple__5); + Py_CLEAR(clear_module_state->__pyx_tuple__7); + Py_CLEAR(clear_module_state->__pyx_tuple__8); + Py_CLEAR(clear_module_state->__pyx_slice__88); + Py_CLEAR(clear_module_state->__pyx_tuple__11); + Py_CLEAR(clear_module_state->__pyx_tuple__12); + Py_CLEAR(clear_module_state->__pyx_tuple__13); + Py_CLEAR(clear_module_state->__pyx_tuple__14); + Py_CLEAR(clear_module_state->__pyx_tuple__15); + Py_CLEAR(clear_module_state->__pyx_tuple__16); + Py_CLEAR(clear_module_state->__pyx_tuple__17); + Py_CLEAR(clear_module_state->__pyx_tuple__18); + Py_CLEAR(clear_module_state->__pyx_tuple__19); + Py_CLEAR(clear_module_state->__pyx_tuple__20); + Py_CLEAR(clear_module_state->__pyx_tuple__21); + Py_CLEAR(clear_module_state->__pyx_tuple__22); + Py_CLEAR(clear_module_state->__pyx_tuple__23); + Py_CLEAR(clear_module_state->__pyx_tuple__24); + Py_CLEAR(clear_module_state->__pyx_tuple__25); + Py_CLEAR(clear_module_state->__pyx_tuple__26); + Py_CLEAR(clear_module_state->__pyx_tuple__27); + Py_CLEAR(clear_module_state->__pyx_tuple__28); + Py_CLEAR(clear_module_state->__pyx_tuple__29); + Py_CLEAR(clear_module_state->__pyx_tuple__30); + Py_CLEAR(clear_module_state->__pyx_tuple__31); + Py_CLEAR(clear_module_state->__pyx_tuple__32); + Py_CLEAR(clear_module_state->__pyx_tuple__33); + Py_CLEAR(clear_module_state->__pyx_tuple__34); + Py_CLEAR(clear_module_state->__pyx_tuple__35); + Py_CLEAR(clear_module_state->__pyx_tuple__36); + Py_CLEAR(clear_module_state->__pyx_tuple__37); + Py_CLEAR(clear_module_state->__pyx_tuple__38); + Py_CLEAR(clear_module_state->__pyx_tuple__39); + Py_CLEAR(clear_module_state->__pyx_tuple__40); + Py_CLEAR(clear_module_state->__pyx_tuple__41); + Py_CLEAR(clear_module_state->__pyx_tuple__42); + Py_CLEAR(clear_module_state->__pyx_tuple__43); + Py_CLEAR(clear_module_state->__pyx_tuple__44); + Py_CLEAR(clear_module_state->__pyx_tuple__45); + Py_CLEAR(clear_module_state->__pyx_tuple__46); + Py_CLEAR(clear_module_state->__pyx_tuple__47); + Py_CLEAR(clear_module_state->__pyx_tuple__48); + Py_CLEAR(clear_module_state->__pyx_tuple__49); + Py_CLEAR(clear_module_state->__pyx_tuple__50); + Py_CLEAR(clear_module_state->__pyx_tuple__51); + Py_CLEAR(clear_module_state->__pyx_tuple__52); + Py_CLEAR(clear_module_state->__pyx_tuple__53); + Py_CLEAR(clear_module_state->__pyx_tuple__54); + Py_CLEAR(clear_module_state->__pyx_tuple__55); + Py_CLEAR(clear_module_state->__pyx_tuple__56); + Py_CLEAR(clear_module_state->__pyx_tuple__57); + Py_CLEAR(clear_module_state->__pyx_tuple__58); + Py_CLEAR(clear_module_state->__pyx_tuple__59); + Py_CLEAR(clear_module_state->__pyx_tuple__60); + Py_CLEAR(clear_module_state->__pyx_tuple__61); + Py_CLEAR(clear_module_state->__pyx_tuple__62); + Py_CLEAR(clear_module_state->__pyx_tuple__63); + Py_CLEAR(clear_module_state->__pyx_tuple__64); + Py_CLEAR(clear_module_state->__pyx_tuple__65); + Py_CLEAR(clear_module_state->__pyx_tuple__66); + Py_CLEAR(clear_module_state->__pyx_tuple__67); + Py_CLEAR(clear_module_state->__pyx_tuple__68); + Py_CLEAR(clear_module_state->__pyx_tuple__69); + Py_CLEAR(clear_module_state->__pyx_tuple__70); + Py_CLEAR(clear_module_state->__pyx_tuple__71); + Py_CLEAR(clear_module_state->__pyx_tuple__72); + Py_CLEAR(clear_module_state->__pyx_tuple__73); + Py_CLEAR(clear_module_state->__pyx_tuple__74); + Py_CLEAR(clear_module_state->__pyx_tuple__75); + Py_CLEAR(clear_module_state->__pyx_tuple__76); + Py_CLEAR(clear_module_state->__pyx_tuple__77); + Py_CLEAR(clear_module_state->__pyx_tuple__78); + Py_CLEAR(clear_module_state->__pyx_tuple__80); + Py_CLEAR(clear_module_state->__pyx_tuple__81); + Py_CLEAR(clear_module_state->__pyx_tuple__82); + Py_CLEAR(clear_module_state->__pyx_tuple__83); + Py_CLEAR(clear_module_state->__pyx_tuple__84); + Py_CLEAR(clear_module_state->__pyx_tuple__85); + Py_CLEAR(clear_module_state->__pyx_tuple__86); + Py_CLEAR(clear_module_state->__pyx_tuple__87); + Py_CLEAR(clear_module_state->__pyx_tuple__90); + Py_CLEAR(clear_module_state->__pyx_tuple__91); + Py_CLEAR(clear_module_state->__pyx_tuple__92); + Py_CLEAR(clear_module_state->__pyx_tuple__96); + Py_CLEAR(clear_module_state->__pyx_tuple__97); + Py_CLEAR(clear_module_state->__pyx_tuple__98); + Py_CLEAR(clear_module_state->__pyx_tuple__99); + Py_CLEAR(clear_module_state->__pyx_tuple__100); + Py_CLEAR(clear_module_state->__pyx_tuple__107); + Py_CLEAR(clear_module_state->__pyx_tuple__108); + Py_CLEAR(clear_module_state->__pyx_tuple__109); + Py_CLEAR(clear_module_state->__pyx_tuple__110); + Py_CLEAR(clear_module_state->__pyx_tuple__111); + Py_CLEAR(clear_module_state->__pyx_tuple__112); + Py_CLEAR(clear_module_state->__pyx_tuple__113); + Py_CLEAR(clear_module_state->__pyx_tuple__115); + Py_CLEAR(clear_module_state->__pyx_tuple__116); + Py_CLEAR(clear_module_state->__pyx_tuple__117); + Py_CLEAR(clear_module_state->__pyx_tuple__118); + Py_CLEAR(clear_module_state->__pyx_tuple__119); + Py_CLEAR(clear_module_state->__pyx_tuple__120); + Py_CLEAR(clear_module_state->__pyx_tuple__121); + Py_CLEAR(clear_module_state->__pyx_tuple__122); + Py_CLEAR(clear_module_state->__pyx_tuple__123); + Py_CLEAR(clear_module_state->__pyx_tuple__124); + Py_CLEAR(clear_module_state->__pyx_tuple__125); + Py_CLEAR(clear_module_state->__pyx_tuple__127); + Py_CLEAR(clear_module_state->__pyx_tuple__129); + Py_CLEAR(clear_module_state->__pyx_tuple__131); + Py_CLEAR(clear_module_state->__pyx_tuple__132); + Py_CLEAR(clear_module_state->__pyx_tuple__134); + Py_CLEAR(clear_module_state->__pyx_tuple__136); + Py_CLEAR(clear_module_state->__pyx_tuple__138); + Py_CLEAR(clear_module_state->__pyx_tuple__141); + Py_CLEAR(clear_module_state->__pyx_tuple__143); + Py_CLEAR(clear_module_state->__pyx_tuple__145); + Py_CLEAR(clear_module_state->__pyx_tuple__147); + Py_CLEAR(clear_module_state->__pyx_tuple__149); + Py_CLEAR(clear_module_state->__pyx_tuple__151); + Py_CLEAR(clear_module_state->__pyx_tuple__153); + Py_CLEAR(clear_module_state->__pyx_tuple__155); + Py_CLEAR(clear_module_state->__pyx_tuple__159); + Py_CLEAR(clear_module_state->__pyx_tuple__182); + Py_CLEAR(clear_module_state->__pyx_tuple__188); + Py_CLEAR(clear_module_state->__pyx_tuple__190); + Py_CLEAR(clear_module_state->__pyx_tuple__192); + Py_CLEAR(clear_module_state->__pyx_tuple__194); + Py_CLEAR(clear_module_state->__pyx_tuple__198); + Py_CLEAR(clear_module_state->__pyx_tuple__200); + Py_CLEAR(clear_module_state->__pyx_tuple__202); + Py_CLEAR(clear_module_state->__pyx_tuple__203); + Py_CLEAR(clear_module_state->__pyx_tuple__205); + Py_CLEAR(clear_module_state->__pyx_tuple__207); + Py_CLEAR(clear_module_state->__pyx_tuple__209); + Py_CLEAR(clear_module_state->__pyx_tuple__210); + Py_CLEAR(clear_module_state->__pyx_tuple__212); + Py_CLEAR(clear_module_state->__pyx_tuple__213); + Py_CLEAR(clear_module_state->__pyx_tuple__215); + Py_CLEAR(clear_module_state->__pyx_tuple__217); + Py_CLEAR(clear_module_state->__pyx_tuple__218); + Py_CLEAR(clear_module_state->__pyx_tuple__220); + Py_CLEAR(clear_module_state->__pyx_tuple__222); + Py_CLEAR(clear_module_state->__pyx_tuple__224); + Py_CLEAR(clear_module_state->__pyx_tuple__226); + Py_CLEAR(clear_module_state->__pyx_tuple__229); + Py_CLEAR(clear_module_state->__pyx_tuple__231); + Py_CLEAR(clear_module_state->__pyx_tuple__233); + Py_CLEAR(clear_module_state->__pyx_tuple__235); + Py_CLEAR(clear_module_state->__pyx_tuple__238); + Py_CLEAR(clear_module_state->__pyx_tuple__241); + Py_CLEAR(clear_module_state->__pyx_tuple__243); + Py_CLEAR(clear_module_state->__pyx_tuple__245); + Py_CLEAR(clear_module_state->__pyx_tuple__247); + Py_CLEAR(clear_module_state->__pyx_tuple__249); + Py_CLEAR(clear_module_state->__pyx_tuple__260); + Py_CLEAR(clear_module_state->__pyx_tuple__262); + Py_CLEAR(clear_module_state->__pyx_tuple__264); + Py_CLEAR(clear_module_state->__pyx_tuple__266); + Py_CLEAR(clear_module_state->__pyx_tuple__268); + Py_CLEAR(clear_module_state->__pyx_tuple__271); + Py_CLEAR(clear_module_state->__pyx_tuple__280); + Py_CLEAR(clear_module_state->__pyx_tuple__289); + Py_CLEAR(clear_module_state->__pyx_tuple__296); + Py_CLEAR(clear_module_state->__pyx_tuple__302); + Py_CLEAR(clear_module_state->__pyx_tuple__304); + Py_CLEAR(clear_module_state->__pyx_tuple__306); + Py_CLEAR(clear_module_state->__pyx_tuple__309); + Py_CLEAR(clear_module_state->__pyx_tuple__311); + Py_CLEAR(clear_module_state->__pyx_tuple__313); + Py_CLEAR(clear_module_state->__pyx_tuple__315); + Py_CLEAR(clear_module_state->__pyx_tuple__317); + Py_CLEAR(clear_module_state->__pyx_tuple__319); + Py_CLEAR(clear_module_state->__pyx_tuple__321); + Py_CLEAR(clear_module_state->__pyx_tuple__323); + Py_CLEAR(clear_module_state->__pyx_tuple__326); + Py_CLEAR(clear_module_state->__pyx_tuple__348); + Py_CLEAR(clear_module_state->__pyx_tuple__359); + Py_CLEAR(clear_module_state->__pyx_tuple__368); + Py_CLEAR(clear_module_state->__pyx_tuple__377); + Py_CLEAR(clear_module_state->__pyx_tuple__394); + Py_CLEAR(clear_module_state->__pyx_tuple__398); + Py_CLEAR(clear_module_state->__pyx_tuple__400); + Py_CLEAR(clear_module_state->__pyx_tuple__402); + Py_CLEAR(clear_module_state->__pyx_tuple__412); + Py_CLEAR(clear_module_state->__pyx_tuple__418); + Py_CLEAR(clear_module_state->__pyx_tuple__436); + Py_CLEAR(clear_module_state->__pyx_tuple__440); + Py_CLEAR(clear_module_state->__pyx_tuple__471); + Py_CLEAR(clear_module_state->__pyx_tuple__475); + Py_CLEAR(clear_module_state->__pyx_tuple__479); + Py_CLEAR(clear_module_state->__pyx_tuple__481); + Py_CLEAR(clear_module_state->__pyx_tuple__483); + Py_CLEAR(clear_module_state->__pyx_tuple__488); + Py_CLEAR(clear_module_state->__pyx_tuple__509); + Py_CLEAR(clear_module_state->__pyx_tuple__513); + Py_CLEAR(clear_module_state->__pyx_tuple__515); + Py_CLEAR(clear_module_state->__pyx_tuple__521); + Py_CLEAR(clear_module_state->__pyx_tuple__528); + Py_CLEAR(clear_module_state->__pyx_tuple__530); + Py_CLEAR(clear_module_state->__pyx_tuple__541); + Py_CLEAR(clear_module_state->__pyx_tuple__551); + Py_CLEAR(clear_module_state->__pyx_tuple__556); + Py_CLEAR(clear_module_state->__pyx_tuple__558); + Py_CLEAR(clear_module_state->__pyx_tuple__560); + Py_CLEAR(clear_module_state->__pyx_tuple__562); + Py_CLEAR(clear_module_state->__pyx_tuple__567); + Py_CLEAR(clear_module_state->__pyx_tuple__572); + Py_CLEAR(clear_module_state->__pyx_tuple__596); + Py_CLEAR(clear_module_state->__pyx_tuple__602); + Py_CLEAR(clear_module_state->__pyx_tuple__604); + Py_CLEAR(clear_module_state->__pyx_tuple__607); + Py_CLEAR(clear_module_state->__pyx_tuple__609); + Py_CLEAR(clear_module_state->__pyx_tuple__611); + Py_CLEAR(clear_module_state->__pyx_tuple__614); + Py_CLEAR(clear_module_state->__pyx_tuple__636); + Py_CLEAR(clear_module_state->__pyx_tuple__644); + Py_CLEAR(clear_module_state->__pyx_tuple__651); + Py_CLEAR(clear_module_state->__pyx_tuple__653); + Py_CLEAR(clear_module_state->__pyx_tuple__654); + Py_CLEAR(clear_module_state->__pyx_tuple__656); + Py_CLEAR(clear_module_state->__pyx_tuple__660); + Py_CLEAR(clear_module_state->__pyx_tuple__663); + Py_CLEAR(clear_module_state->__pyx_tuple__665); + Py_CLEAR(clear_module_state->__pyx_tuple__666); + Py_CLEAR(clear_module_state->__pyx_tuple__668); + Py_CLEAR(clear_module_state->__pyx_tuple__670); + Py_CLEAR(clear_module_state->__pyx_tuple__674); + Py_CLEAR(clear_module_state->__pyx_tuple__676); + Py_CLEAR(clear_module_state->__pyx_tuple__680); + Py_CLEAR(clear_module_state->__pyx_tuple__682); + Py_CLEAR(clear_module_state->__pyx_tuple__684); + Py_CLEAR(clear_module_state->__pyx_tuple__685); + Py_CLEAR(clear_module_state->__pyx_tuple__687); + Py_CLEAR(clear_module_state->__pyx_tuple__688); + Py_CLEAR(clear_module_state->__pyx_tuple__690); + Py_CLEAR(clear_module_state->__pyx_tuple__692); + Py_CLEAR(clear_module_state->__pyx_tuple__694); + Py_CLEAR(clear_module_state->__pyx_tuple__696); + Py_CLEAR(clear_module_state->__pyx_tuple__698); + Py_CLEAR(clear_module_state->__pyx_tuple__702); + Py_CLEAR(clear_module_state->__pyx_tuple__704); + Py_CLEAR(clear_module_state->__pyx_tuple__708); + Py_CLEAR(clear_module_state->__pyx_tuple__710); + Py_CLEAR(clear_module_state->__pyx_tuple__712); + Py_CLEAR(clear_module_state->__pyx_tuple__714); + Py_CLEAR(clear_module_state->__pyx_tuple__716); + Py_CLEAR(clear_module_state->__pyx_tuple__720); + Py_CLEAR(clear_module_state->__pyx_tuple__722); + Py_CLEAR(clear_module_state->__pyx_tuple__730); + Py_CLEAR(clear_module_state->__pyx_tuple__734); + Py_CLEAR(clear_module_state->__pyx_tuple__737); + Py_CLEAR(clear_module_state->__pyx_tuple__739); + Py_CLEAR(clear_module_state->__pyx_tuple__743); + Py_CLEAR(clear_module_state->__pyx_tuple__745); + Py_CLEAR(clear_module_state->__pyx_tuple__747); + Py_CLEAR(clear_module_state->__pyx_tuple__750); + Py_CLEAR(clear_module_state->__pyx_tuple__752); + Py_CLEAR(clear_module_state->__pyx_tuple__753); + Py_CLEAR(clear_module_state->__pyx_tuple__760); + Py_CLEAR(clear_module_state->__pyx_tuple__765); + Py_CLEAR(clear_module_state->__pyx_tuple__767); + Py_CLEAR(clear_module_state->__pyx_tuple__770); + Py_CLEAR(clear_module_state->__pyx_tuple__772); + Py_CLEAR(clear_module_state->__pyx_tuple__775); + Py_CLEAR(clear_module_state->__pyx_tuple__780); + Py_CLEAR(clear_module_state->__pyx_tuple__782); + Py_CLEAR(clear_module_state->__pyx_tuple__783); + Py_CLEAR(clear_module_state->__pyx_tuple__785); + Py_CLEAR(clear_module_state->__pyx_tuple__787); + Py_CLEAR(clear_module_state->__pyx_tuple__789); + Py_CLEAR(clear_module_state->__pyx_tuple__791); + Py_CLEAR(clear_module_state->__pyx_tuple__793); + Py_CLEAR(clear_module_state->__pyx_tuple__794); + Py_CLEAR(clear_module_state->__pyx_tuple__796); + Py_CLEAR(clear_module_state->__pyx_tuple__798); + Py_CLEAR(clear_module_state->__pyx_tuple__800); + Py_CLEAR(clear_module_state->__pyx_tuple__801); + Py_CLEAR(clear_module_state->__pyx_tuple__803); + Py_CLEAR(clear_module_state->__pyx_tuple__805); + Py_CLEAR(clear_module_state->__pyx_tuple__808); + Py_CLEAR(clear_module_state->__pyx_tuple__810); + Py_CLEAR(clear_module_state->__pyx_tuple__812); + Py_CLEAR(clear_module_state->__pyx_tuple__814); + Py_CLEAR(clear_module_state->__pyx_tuple__816); + Py_CLEAR(clear_module_state->__pyx_tuple__818); + Py_CLEAR(clear_module_state->__pyx_tuple__820); + Py_CLEAR(clear_module_state->__pyx_tuple__821); + Py_CLEAR(clear_module_state->__pyx_tuple__823); + Py_CLEAR(clear_module_state->__pyx_tuple__825); + Py_CLEAR(clear_module_state->__pyx_tuple__826); + Py_CLEAR(clear_module_state->__pyx_tuple__828); + Py_CLEAR(clear_module_state->__pyx_tuple__829); + Py_CLEAR(clear_module_state->__pyx_tuple__831); + Py_CLEAR(clear_module_state->__pyx_tuple__832); + Py_CLEAR(clear_module_state->__pyx_tuple__834); + Py_CLEAR(clear_module_state->__pyx_tuple__835); + Py_CLEAR(clear_module_state->__pyx_tuple__837); + Py_CLEAR(clear_module_state->__pyx_tuple__839); + Py_CLEAR(clear_module_state->__pyx_tuple__844); + Py_CLEAR(clear_module_state->__pyx_tuple__846); + Py_CLEAR(clear_module_state->__pyx_tuple__848); + Py_CLEAR(clear_module_state->__pyx_tuple__850); + Py_CLEAR(clear_module_state->__pyx_tuple__852); + Py_CLEAR(clear_module_state->__pyx_tuple__854); + Py_CLEAR(clear_module_state->__pyx_tuple__856); + Py_CLEAR(clear_module_state->__pyx_tuple__859); + Py_CLEAR(clear_module_state->__pyx_tuple__863); + Py_CLEAR(clear_module_state->__pyx_tuple__865); + Py_CLEAR(clear_module_state->__pyx_tuple__867); + Py_CLEAR(clear_module_state->__pyx_tuple__871); + Py_CLEAR(clear_module_state->__pyx_tuple__873); + Py_CLEAR(clear_module_state->__pyx_tuple__875); + Py_CLEAR(clear_module_state->__pyx_tuple__877); + Py_CLEAR(clear_module_state->__pyx_tuple__879); + Py_CLEAR(clear_module_state->__pyx_tuple__881); + Py_CLEAR(clear_module_state->__pyx_tuple__883); + Py_CLEAR(clear_module_state->__pyx_tuple__885); + Py_CLEAR(clear_module_state->__pyx_tuple__887); + Py_CLEAR(clear_module_state->__pyx_tuple__892); + Py_CLEAR(clear_module_state->__pyx_tuple__894); + Py_CLEAR(clear_module_state->__pyx_tuple__896); + Py_CLEAR(clear_module_state->__pyx_tuple__900); + Py_CLEAR(clear_module_state->__pyx_tuple__902); + Py_CLEAR(clear_module_state->__pyx_tuple__907); + Py_CLEAR(clear_module_state->__pyx_tuple__909); + Py_CLEAR(clear_module_state->__pyx_tuple__911); + Py_CLEAR(clear_module_state->__pyx_tuple__913); + Py_CLEAR(clear_module_state->__pyx_tuple__915); + Py_CLEAR(clear_module_state->__pyx_tuple__917); + Py_CLEAR(clear_module_state->__pyx_tuple__919); + Py_CLEAR(clear_module_state->__pyx_tuple__921); + Py_CLEAR(clear_module_state->__pyx_tuple__923); + Py_CLEAR(clear_module_state->__pyx_tuple__925); + Py_CLEAR(clear_module_state->__pyx_tuple__927); + Py_CLEAR(clear_module_state->__pyx_tuple__929); + Py_CLEAR(clear_module_state->__pyx_tuple__930); + Py_CLEAR(clear_module_state->__pyx_tuple__932); + Py_CLEAR(clear_module_state->__pyx_tuple__934); + Py_CLEAR(clear_module_state->__pyx_tuple__936); + Py_CLEAR(clear_module_state->__pyx_tuple__938); + Py_CLEAR(clear_module_state->__pyx_tuple__940); + Py_CLEAR(clear_module_state->__pyx_tuple__941); + Py_CLEAR(clear_module_state->__pyx_tuple__943); + Py_CLEAR(clear_module_state->__pyx_tuple__945); + Py_CLEAR(clear_module_state->__pyx_tuple__946); + Py_CLEAR(clear_module_state->__pyx_tuple__948); + Py_CLEAR(clear_module_state->__pyx_tuple__950); + Py_CLEAR(clear_module_state->__pyx_tuple__951); + Py_CLEAR(clear_module_state->__pyx_tuple__953); + Py_CLEAR(clear_module_state->__pyx_tuple__955); + Py_CLEAR(clear_module_state->__pyx_tuple__957); + Py_CLEAR(clear_module_state->__pyx_tuple__959); + Py_CLEAR(clear_module_state->__pyx_tuple__960); + Py_CLEAR(clear_module_state->__pyx_tuple__962); + Py_CLEAR(clear_module_state->__pyx_tuple__964); + Py_CLEAR(clear_module_state->__pyx_tuple__966); + Py_CLEAR(clear_module_state->__pyx_tuple__968); + Py_CLEAR(clear_module_state->__pyx_tuple__969); + Py_CLEAR(clear_module_state->__pyx_tuple__971); + Py_CLEAR(clear_module_state->__pyx_tuple__973); + Py_CLEAR(clear_module_state->__pyx_tuple__975); + Py_CLEAR(clear_module_state->__pyx_tuple__977); + Py_CLEAR(clear_module_state->__pyx_tuple__979); + Py_CLEAR(clear_module_state->__pyx_tuple__981); + Py_CLEAR(clear_module_state->__pyx_tuple__983); + Py_CLEAR(clear_module_state->__pyx_tuple__987); + Py_CLEAR(clear_module_state->__pyx_tuple__989); + Py_CLEAR(clear_module_state->__pyx_tuple__994); + Py_CLEAR(clear_module_state->__pyx_tuple__996); + Py_CLEAR(clear_module_state->__pyx_tuple__999); + Py_CLEAR(clear_module_state->__pyx_codeobj__93); + Py_CLEAR(clear_module_state->__pyx_codeobj__95); + Py_CLEAR(clear_module_state->__pyx_tuple__1001); + Py_CLEAR(clear_module_state->__pyx_tuple__1006); + Py_CLEAR(clear_module_state->__pyx_tuple__1012); + Py_CLEAR(clear_module_state->__pyx_tuple__1018); + Py_CLEAR(clear_module_state->__pyx_tuple__1022); + Py_CLEAR(clear_module_state->__pyx_tuple__1024); + Py_CLEAR(clear_module_state->__pyx_tuple__1025); + Py_CLEAR(clear_module_state->__pyx_tuple__1027); + Py_CLEAR(clear_module_state->__pyx_tuple__1030); + Py_CLEAR(clear_module_state->__pyx_tuple__1032); + Py_CLEAR(clear_module_state->__pyx_tuple__1034); + Py_CLEAR(clear_module_state->__pyx_tuple__1035); + Py_CLEAR(clear_module_state->__pyx_tuple__1037); + Py_CLEAR(clear_module_state->__pyx_tuple__1039); + Py_CLEAR(clear_module_state->__pyx_tuple__1040); + Py_CLEAR(clear_module_state->__pyx_tuple__1044); + Py_CLEAR(clear_module_state->__pyx_tuple__1046); + Py_CLEAR(clear_module_state->__pyx_tuple__1048); + Py_CLEAR(clear_module_state->__pyx_tuple__1050); + Py_CLEAR(clear_module_state->__pyx_tuple__1051); + Py_CLEAR(clear_module_state->__pyx_tuple__1053); + Py_CLEAR(clear_module_state->__pyx_tuple__1054); + Py_CLEAR(clear_module_state->__pyx_tuple__1061); + Py_CLEAR(clear_module_state->__pyx_tuple__1064); + Py_CLEAR(clear_module_state->__pyx_tuple__1066); + Py_CLEAR(clear_module_state->__pyx_tuple__1069); + Py_CLEAR(clear_module_state->__pyx_tuple__1071); + Py_CLEAR(clear_module_state->__pyx_tuple__1075); + Py_CLEAR(clear_module_state->__pyx_tuple__1080); + Py_CLEAR(clear_module_state->__pyx_tuple__1086); + Py_CLEAR(clear_module_state->__pyx_tuple__1088); + Py_CLEAR(clear_module_state->__pyx_tuple__1091); + Py_CLEAR(clear_module_state->__pyx_tuple__1094); + Py_CLEAR(clear_module_state->__pyx_tuple__1098); + Py_CLEAR(clear_module_state->__pyx_tuple__1100); + Py_CLEAR(clear_module_state->__pyx_tuple__1102); + Py_CLEAR(clear_module_state->__pyx_tuple__1104); + Py_CLEAR(clear_module_state->__pyx_tuple__1106); + Py_CLEAR(clear_module_state->__pyx_tuple__1108); + Py_CLEAR(clear_module_state->__pyx_tuple__1114); + Py_CLEAR(clear_module_state->__pyx_tuple__1116); + Py_CLEAR(clear_module_state->__pyx_tuple__1118); + Py_CLEAR(clear_module_state->__pyx_tuple__1120); + Py_CLEAR(clear_module_state->__pyx_tuple__1122); + Py_CLEAR(clear_module_state->__pyx_tuple__1124); + Py_CLEAR(clear_module_state->__pyx_tuple__1126); + Py_CLEAR(clear_module_state->__pyx_tuple__1128); + Py_CLEAR(clear_module_state->__pyx_tuple__1131); + Py_CLEAR(clear_module_state->__pyx_tuple__1133); + Py_CLEAR(clear_module_state->__pyx_tuple__1137); + Py_CLEAR(clear_module_state->__pyx_tuple__1141); + Py_CLEAR(clear_module_state->__pyx_tuple__1143); + Py_CLEAR(clear_module_state->__pyx_tuple__1144); + Py_CLEAR(clear_module_state->__pyx_tuple__1151); + Py_CLEAR(clear_module_state->__pyx_codeobj__128); + Py_CLEAR(clear_module_state->__pyx_codeobj__130); + Py_CLEAR(clear_module_state->__pyx_codeobj__133); + Py_CLEAR(clear_module_state->__pyx_codeobj__135); + Py_CLEAR(clear_module_state->__pyx_codeobj__137); + Py_CLEAR(clear_module_state->__pyx_codeobj__139); + Py_CLEAR(clear_module_state->__pyx_codeobj__140); + Py_CLEAR(clear_module_state->__pyx_codeobj__142); + Py_CLEAR(clear_module_state->__pyx_codeobj__144); + Py_CLEAR(clear_module_state->__pyx_codeobj__146); + Py_CLEAR(clear_module_state->__pyx_codeobj__148); + Py_CLEAR(clear_module_state->__pyx_codeobj__150); + Py_CLEAR(clear_module_state->__pyx_codeobj__152); + Py_CLEAR(clear_module_state->__pyx_codeobj__154); + Py_CLEAR(clear_module_state->__pyx_codeobj__156); + Py_CLEAR(clear_module_state->__pyx_codeobj__157); + Py_CLEAR(clear_module_state->__pyx_codeobj__158); + Py_CLEAR(clear_module_state->__pyx_codeobj__160); + Py_CLEAR(clear_module_state->__pyx_codeobj__161); + Py_CLEAR(clear_module_state->__pyx_codeobj__166); + Py_CLEAR(clear_module_state->__pyx_codeobj__167); + Py_CLEAR(clear_module_state->__pyx_codeobj__168); + Py_CLEAR(clear_module_state->__pyx_codeobj__169); + Py_CLEAR(clear_module_state->__pyx_codeobj__170); + Py_CLEAR(clear_module_state->__pyx_codeobj__171); + Py_CLEAR(clear_module_state->__pyx_codeobj__172); + Py_CLEAR(clear_module_state->__pyx_codeobj__173); + Py_CLEAR(clear_module_state->__pyx_codeobj__174); + Py_CLEAR(clear_module_state->__pyx_codeobj__175); + Py_CLEAR(clear_module_state->__pyx_codeobj__176); + Py_CLEAR(clear_module_state->__pyx_codeobj__177); + Py_CLEAR(clear_module_state->__pyx_codeobj__178); + Py_CLEAR(clear_module_state->__pyx_codeobj__179); + Py_CLEAR(clear_module_state->__pyx_codeobj__180); + Py_CLEAR(clear_module_state->__pyx_codeobj__181); + Py_CLEAR(clear_module_state->__pyx_codeobj__183); + Py_CLEAR(clear_module_state->__pyx_codeobj__184); + Py_CLEAR(clear_module_state->__pyx_codeobj__185); + Py_CLEAR(clear_module_state->__pyx_codeobj__186); + Py_CLEAR(clear_module_state->__pyx_codeobj__187); + Py_CLEAR(clear_module_state->__pyx_codeobj__189); + Py_CLEAR(clear_module_state->__pyx_codeobj__191); + Py_CLEAR(clear_module_state->__pyx_codeobj__193); + Py_CLEAR(clear_module_state->__pyx_codeobj__195); + Py_CLEAR(clear_module_state->__pyx_codeobj__196); + Py_CLEAR(clear_module_state->__pyx_codeobj__197); + Py_CLEAR(clear_module_state->__pyx_codeobj__199); + Py_CLEAR(clear_module_state->__pyx_codeobj__201); + Py_CLEAR(clear_module_state->__pyx_codeobj__204); + Py_CLEAR(clear_module_state->__pyx_codeobj__206); + Py_CLEAR(clear_module_state->__pyx_codeobj__208); + Py_CLEAR(clear_module_state->__pyx_codeobj__211); + Py_CLEAR(clear_module_state->__pyx_codeobj__214); + Py_CLEAR(clear_module_state->__pyx_codeobj__216); + Py_CLEAR(clear_module_state->__pyx_codeobj__219); + Py_CLEAR(clear_module_state->__pyx_codeobj__221); + Py_CLEAR(clear_module_state->__pyx_codeobj__223); + Py_CLEAR(clear_module_state->__pyx_codeobj__225); + Py_CLEAR(clear_module_state->__pyx_codeobj__227); + Py_CLEAR(clear_module_state->__pyx_codeobj__228); + Py_CLEAR(clear_module_state->__pyx_codeobj__230); + Py_CLEAR(clear_module_state->__pyx_codeobj__232); + Py_CLEAR(clear_module_state->__pyx_codeobj__234); + Py_CLEAR(clear_module_state->__pyx_codeobj__236); + Py_CLEAR(clear_module_state->__pyx_codeobj__237); + Py_CLEAR(clear_module_state->__pyx_codeobj__239); + Py_CLEAR(clear_module_state->__pyx_codeobj__240); + Py_CLEAR(clear_module_state->__pyx_codeobj__242); + Py_CLEAR(clear_module_state->__pyx_codeobj__244); + Py_CLEAR(clear_module_state->__pyx_codeobj__246); + Py_CLEAR(clear_module_state->__pyx_codeobj__248); + Py_CLEAR(clear_module_state->__pyx_codeobj__250); + Py_CLEAR(clear_module_state->__pyx_codeobj__251); + Py_CLEAR(clear_module_state->__pyx_codeobj__252); + Py_CLEAR(clear_module_state->__pyx_codeobj__253); + Py_CLEAR(clear_module_state->__pyx_codeobj__254); + Py_CLEAR(clear_module_state->__pyx_codeobj__255); + Py_CLEAR(clear_module_state->__pyx_codeobj__256); + Py_CLEAR(clear_module_state->__pyx_codeobj__257); + Py_CLEAR(clear_module_state->__pyx_codeobj__258); + Py_CLEAR(clear_module_state->__pyx_codeobj__259); + Py_CLEAR(clear_module_state->__pyx_codeobj__261); + Py_CLEAR(clear_module_state->__pyx_codeobj__263); + Py_CLEAR(clear_module_state->__pyx_codeobj__265); + Py_CLEAR(clear_module_state->__pyx_codeobj__267); + Py_CLEAR(clear_module_state->__pyx_codeobj__269); + Py_CLEAR(clear_module_state->__pyx_codeobj__270); + Py_CLEAR(clear_module_state->__pyx_codeobj__272); + Py_CLEAR(clear_module_state->__pyx_codeobj__273); + Py_CLEAR(clear_module_state->__pyx_codeobj__274); + Py_CLEAR(clear_module_state->__pyx_codeobj__275); + Py_CLEAR(clear_module_state->__pyx_codeobj__276); + Py_CLEAR(clear_module_state->__pyx_codeobj__277); + Py_CLEAR(clear_module_state->__pyx_codeobj__278); + Py_CLEAR(clear_module_state->__pyx_codeobj__279); + Py_CLEAR(clear_module_state->__pyx_codeobj__281); + Py_CLEAR(clear_module_state->__pyx_codeobj__282); + Py_CLEAR(clear_module_state->__pyx_codeobj__283); + Py_CLEAR(clear_module_state->__pyx_codeobj__284); + Py_CLEAR(clear_module_state->__pyx_codeobj__285); + Py_CLEAR(clear_module_state->__pyx_codeobj__286); + Py_CLEAR(clear_module_state->__pyx_codeobj__287); + Py_CLEAR(clear_module_state->__pyx_codeobj__288); + Py_CLEAR(clear_module_state->__pyx_codeobj__290); + Py_CLEAR(clear_module_state->__pyx_codeobj__291); + Py_CLEAR(clear_module_state->__pyx_codeobj__292); + Py_CLEAR(clear_module_state->__pyx_codeobj__293); + Py_CLEAR(clear_module_state->__pyx_codeobj__294); + Py_CLEAR(clear_module_state->__pyx_codeobj__295); + Py_CLEAR(clear_module_state->__pyx_codeobj__297); + Py_CLEAR(clear_module_state->__pyx_codeobj__298); + Py_CLEAR(clear_module_state->__pyx_codeobj__299); + Py_CLEAR(clear_module_state->__pyx_codeobj__300); + Py_CLEAR(clear_module_state->__pyx_codeobj__301); + Py_CLEAR(clear_module_state->__pyx_codeobj__303); + Py_CLEAR(clear_module_state->__pyx_codeobj__305); + Py_CLEAR(clear_module_state->__pyx_codeobj__307); + Py_CLEAR(clear_module_state->__pyx_codeobj__308); + Py_CLEAR(clear_module_state->__pyx_codeobj__310); + Py_CLEAR(clear_module_state->__pyx_codeobj__312); + Py_CLEAR(clear_module_state->__pyx_codeobj__314); + Py_CLEAR(clear_module_state->__pyx_codeobj__316); + Py_CLEAR(clear_module_state->__pyx_codeobj__318); + Py_CLEAR(clear_module_state->__pyx_codeobj__320); + Py_CLEAR(clear_module_state->__pyx_codeobj__322); + Py_CLEAR(clear_module_state->__pyx_codeobj__324); + Py_CLEAR(clear_module_state->__pyx_codeobj__325); + Py_CLEAR(clear_module_state->__pyx_codeobj__327); + Py_CLEAR(clear_module_state->__pyx_codeobj__328); + Py_CLEAR(clear_module_state->__pyx_codeobj__329); + Py_CLEAR(clear_module_state->__pyx_codeobj__330); + Py_CLEAR(clear_module_state->__pyx_codeobj__331); + Py_CLEAR(clear_module_state->__pyx_codeobj__332); + Py_CLEAR(clear_module_state->__pyx_codeobj__333); + Py_CLEAR(clear_module_state->__pyx_codeobj__334); + Py_CLEAR(clear_module_state->__pyx_codeobj__335); + Py_CLEAR(clear_module_state->__pyx_codeobj__336); + Py_CLEAR(clear_module_state->__pyx_codeobj__337); + Py_CLEAR(clear_module_state->__pyx_codeobj__338); + Py_CLEAR(clear_module_state->__pyx_codeobj__339); + Py_CLEAR(clear_module_state->__pyx_codeobj__340); + Py_CLEAR(clear_module_state->__pyx_codeobj__341); + Py_CLEAR(clear_module_state->__pyx_codeobj__342); + Py_CLEAR(clear_module_state->__pyx_codeobj__343); + Py_CLEAR(clear_module_state->__pyx_codeobj__344); + Py_CLEAR(clear_module_state->__pyx_codeobj__345); + Py_CLEAR(clear_module_state->__pyx_codeobj__346); + Py_CLEAR(clear_module_state->__pyx_codeobj__347); + Py_CLEAR(clear_module_state->__pyx_codeobj__349); + Py_CLEAR(clear_module_state->__pyx_codeobj__350); + Py_CLEAR(clear_module_state->__pyx_codeobj__351); + Py_CLEAR(clear_module_state->__pyx_codeobj__352); + Py_CLEAR(clear_module_state->__pyx_codeobj__353); + Py_CLEAR(clear_module_state->__pyx_codeobj__354); + Py_CLEAR(clear_module_state->__pyx_codeobj__355); + Py_CLEAR(clear_module_state->__pyx_codeobj__356); + Py_CLEAR(clear_module_state->__pyx_codeobj__357); + Py_CLEAR(clear_module_state->__pyx_codeobj__358); + Py_CLEAR(clear_module_state->__pyx_codeobj__360); + Py_CLEAR(clear_module_state->__pyx_codeobj__361); + Py_CLEAR(clear_module_state->__pyx_codeobj__362); + Py_CLEAR(clear_module_state->__pyx_codeobj__363); + Py_CLEAR(clear_module_state->__pyx_codeobj__364); + Py_CLEAR(clear_module_state->__pyx_codeobj__365); + Py_CLEAR(clear_module_state->__pyx_codeobj__366); + Py_CLEAR(clear_module_state->__pyx_codeobj__367); + Py_CLEAR(clear_module_state->__pyx_codeobj__369); + Py_CLEAR(clear_module_state->__pyx_codeobj__370); + Py_CLEAR(clear_module_state->__pyx_codeobj__371); + Py_CLEAR(clear_module_state->__pyx_codeobj__372); + Py_CLEAR(clear_module_state->__pyx_codeobj__373); + Py_CLEAR(clear_module_state->__pyx_codeobj__374); + Py_CLEAR(clear_module_state->__pyx_codeobj__375); + Py_CLEAR(clear_module_state->__pyx_codeobj__376); + Py_CLEAR(clear_module_state->__pyx_codeobj__378); + Py_CLEAR(clear_module_state->__pyx_codeobj__379); + Py_CLEAR(clear_module_state->__pyx_codeobj__380); + Py_CLEAR(clear_module_state->__pyx_codeobj__381); + Py_CLEAR(clear_module_state->__pyx_codeobj__382); + Py_CLEAR(clear_module_state->__pyx_codeobj__383); + Py_CLEAR(clear_module_state->__pyx_codeobj__384); + Py_CLEAR(clear_module_state->__pyx_codeobj__385); + Py_CLEAR(clear_module_state->__pyx_codeobj__386); + Py_CLEAR(clear_module_state->__pyx_codeobj__387); + Py_CLEAR(clear_module_state->__pyx_codeobj__388); + Py_CLEAR(clear_module_state->__pyx_codeobj__389); + Py_CLEAR(clear_module_state->__pyx_codeobj__390); + Py_CLEAR(clear_module_state->__pyx_codeobj__391); + Py_CLEAR(clear_module_state->__pyx_codeobj__392); + Py_CLEAR(clear_module_state->__pyx_codeobj__393); + Py_CLEAR(clear_module_state->__pyx_codeobj__395); + Py_CLEAR(clear_module_state->__pyx_codeobj__396); + Py_CLEAR(clear_module_state->__pyx_codeobj__397); + Py_CLEAR(clear_module_state->__pyx_codeobj__399); + Py_CLEAR(clear_module_state->__pyx_codeobj__401); + Py_CLEAR(clear_module_state->__pyx_codeobj__403); + Py_CLEAR(clear_module_state->__pyx_codeobj__404); + Py_CLEAR(clear_module_state->__pyx_codeobj__405); + Py_CLEAR(clear_module_state->__pyx_codeobj__406); + Py_CLEAR(clear_module_state->__pyx_codeobj__407); + Py_CLEAR(clear_module_state->__pyx_codeobj__408); + Py_CLEAR(clear_module_state->__pyx_codeobj__409); + Py_CLEAR(clear_module_state->__pyx_codeobj__410); + Py_CLEAR(clear_module_state->__pyx_codeobj__411); + Py_CLEAR(clear_module_state->__pyx_codeobj__413); + Py_CLEAR(clear_module_state->__pyx_codeobj__414); + Py_CLEAR(clear_module_state->__pyx_codeobj__415); + Py_CLEAR(clear_module_state->__pyx_codeobj__416); + Py_CLEAR(clear_module_state->__pyx_codeobj__417); + Py_CLEAR(clear_module_state->__pyx_codeobj__419); + Py_CLEAR(clear_module_state->__pyx_codeobj__420); + Py_CLEAR(clear_module_state->__pyx_codeobj__421); + Py_CLEAR(clear_module_state->__pyx_codeobj__422); + Py_CLEAR(clear_module_state->__pyx_codeobj__423); + Py_CLEAR(clear_module_state->__pyx_codeobj__424); + Py_CLEAR(clear_module_state->__pyx_codeobj__425); + Py_CLEAR(clear_module_state->__pyx_codeobj__426); + Py_CLEAR(clear_module_state->__pyx_codeobj__427); + Py_CLEAR(clear_module_state->__pyx_codeobj__428); + Py_CLEAR(clear_module_state->__pyx_codeobj__429); + Py_CLEAR(clear_module_state->__pyx_codeobj__430); + Py_CLEAR(clear_module_state->__pyx_codeobj__431); + Py_CLEAR(clear_module_state->__pyx_codeobj__432); + Py_CLEAR(clear_module_state->__pyx_codeobj__433); + Py_CLEAR(clear_module_state->__pyx_codeobj__434); + Py_CLEAR(clear_module_state->__pyx_codeobj__435); + Py_CLEAR(clear_module_state->__pyx_codeobj__437); + Py_CLEAR(clear_module_state->__pyx_codeobj__438); + Py_CLEAR(clear_module_state->__pyx_codeobj__439); + Py_CLEAR(clear_module_state->__pyx_codeobj__443); + Py_CLEAR(clear_module_state->__pyx_codeobj__444); + Py_CLEAR(clear_module_state->__pyx_codeobj__445); + Py_CLEAR(clear_module_state->__pyx_codeobj__446); + Py_CLEAR(clear_module_state->__pyx_codeobj__447); + Py_CLEAR(clear_module_state->__pyx_codeobj__448); + Py_CLEAR(clear_module_state->__pyx_codeobj__449); + Py_CLEAR(clear_module_state->__pyx_codeobj__450); + Py_CLEAR(clear_module_state->__pyx_codeobj__451); + Py_CLEAR(clear_module_state->__pyx_codeobj__452); + Py_CLEAR(clear_module_state->__pyx_codeobj__453); + Py_CLEAR(clear_module_state->__pyx_codeobj__454); + Py_CLEAR(clear_module_state->__pyx_codeobj__455); + Py_CLEAR(clear_module_state->__pyx_codeobj__456); + Py_CLEAR(clear_module_state->__pyx_codeobj__457); + Py_CLEAR(clear_module_state->__pyx_codeobj__458); + Py_CLEAR(clear_module_state->__pyx_codeobj__459); + Py_CLEAR(clear_module_state->__pyx_codeobj__460); + Py_CLEAR(clear_module_state->__pyx_codeobj__461); + Py_CLEAR(clear_module_state->__pyx_codeobj__462); + Py_CLEAR(clear_module_state->__pyx_codeobj__463); + Py_CLEAR(clear_module_state->__pyx_codeobj__464); + Py_CLEAR(clear_module_state->__pyx_codeobj__465); + Py_CLEAR(clear_module_state->__pyx_codeobj__466); + Py_CLEAR(clear_module_state->__pyx_codeobj__467); + Py_CLEAR(clear_module_state->__pyx_codeobj__468); + Py_CLEAR(clear_module_state->__pyx_codeobj__469); + Py_CLEAR(clear_module_state->__pyx_codeobj__470); + Py_CLEAR(clear_module_state->__pyx_codeobj__472); + Py_CLEAR(clear_module_state->__pyx_codeobj__473); + Py_CLEAR(clear_module_state->__pyx_codeobj__474); + Py_CLEAR(clear_module_state->__pyx_codeobj__476); + Py_CLEAR(clear_module_state->__pyx_codeobj__477); + Py_CLEAR(clear_module_state->__pyx_codeobj__478); + Py_CLEAR(clear_module_state->__pyx_codeobj__480); + Py_CLEAR(clear_module_state->__pyx_codeobj__482); + Py_CLEAR(clear_module_state->__pyx_codeobj__484); + Py_CLEAR(clear_module_state->__pyx_codeobj__485); + Py_CLEAR(clear_module_state->__pyx_codeobj__486); + Py_CLEAR(clear_module_state->__pyx_codeobj__487); + Py_CLEAR(clear_module_state->__pyx_codeobj__489); + Py_CLEAR(clear_module_state->__pyx_codeobj__490); + Py_CLEAR(clear_module_state->__pyx_codeobj__491); + Py_CLEAR(clear_module_state->__pyx_codeobj__492); + Py_CLEAR(clear_module_state->__pyx_codeobj__493); + Py_CLEAR(clear_module_state->__pyx_codeobj__494); + Py_CLEAR(clear_module_state->__pyx_codeobj__495); + Py_CLEAR(clear_module_state->__pyx_codeobj__496); + Py_CLEAR(clear_module_state->__pyx_codeobj__497); + Py_CLEAR(clear_module_state->__pyx_codeobj__498); + Py_CLEAR(clear_module_state->__pyx_codeobj__499); + Py_CLEAR(clear_module_state->__pyx_codeobj__500); + Py_CLEAR(clear_module_state->__pyx_codeobj__501); + Py_CLEAR(clear_module_state->__pyx_codeobj__502); + Py_CLEAR(clear_module_state->__pyx_codeobj__503); + Py_CLEAR(clear_module_state->__pyx_codeobj__504); + Py_CLEAR(clear_module_state->__pyx_codeobj__505); + Py_CLEAR(clear_module_state->__pyx_codeobj__506); + Py_CLEAR(clear_module_state->__pyx_codeobj__507); + Py_CLEAR(clear_module_state->__pyx_codeobj__508); + Py_CLEAR(clear_module_state->__pyx_codeobj__510); + Py_CLEAR(clear_module_state->__pyx_codeobj__511); + Py_CLEAR(clear_module_state->__pyx_codeobj__512); + Py_CLEAR(clear_module_state->__pyx_codeobj__514); + Py_CLEAR(clear_module_state->__pyx_codeobj__516); + Py_CLEAR(clear_module_state->__pyx_codeobj__517); + Py_CLEAR(clear_module_state->__pyx_codeobj__518); + Py_CLEAR(clear_module_state->__pyx_codeobj__519); + Py_CLEAR(clear_module_state->__pyx_codeobj__520); + Py_CLEAR(clear_module_state->__pyx_codeobj__522); + Py_CLEAR(clear_module_state->__pyx_codeobj__523); + Py_CLEAR(clear_module_state->__pyx_codeobj__524); + Py_CLEAR(clear_module_state->__pyx_codeobj__525); + Py_CLEAR(clear_module_state->__pyx_codeobj__526); + Py_CLEAR(clear_module_state->__pyx_codeobj__527); + Py_CLEAR(clear_module_state->__pyx_codeobj__529); + Py_CLEAR(clear_module_state->__pyx_codeobj__531); + Py_CLEAR(clear_module_state->__pyx_codeobj__532); + Py_CLEAR(clear_module_state->__pyx_codeobj__533); + Py_CLEAR(clear_module_state->__pyx_codeobj__534); + Py_CLEAR(clear_module_state->__pyx_codeobj__535); + Py_CLEAR(clear_module_state->__pyx_codeobj__536); + Py_CLEAR(clear_module_state->__pyx_codeobj__537); + Py_CLEAR(clear_module_state->__pyx_codeobj__538); + Py_CLEAR(clear_module_state->__pyx_codeobj__539); + Py_CLEAR(clear_module_state->__pyx_codeobj__540); + Py_CLEAR(clear_module_state->__pyx_codeobj__542); + Py_CLEAR(clear_module_state->__pyx_codeobj__543); + Py_CLEAR(clear_module_state->__pyx_codeobj__544); + Py_CLEAR(clear_module_state->__pyx_codeobj__545); + Py_CLEAR(clear_module_state->__pyx_codeobj__546); + Py_CLEAR(clear_module_state->__pyx_codeobj__547); + Py_CLEAR(clear_module_state->__pyx_codeobj__548); + Py_CLEAR(clear_module_state->__pyx_codeobj__549); + Py_CLEAR(clear_module_state->__pyx_codeobj__550); + Py_CLEAR(clear_module_state->__pyx_codeobj__552); + Py_CLEAR(clear_module_state->__pyx_codeobj__553); + Py_CLEAR(clear_module_state->__pyx_codeobj__554); + Py_CLEAR(clear_module_state->__pyx_codeobj__555); + Py_CLEAR(clear_module_state->__pyx_codeobj__557); + Py_CLEAR(clear_module_state->__pyx_codeobj__559); + Py_CLEAR(clear_module_state->__pyx_codeobj__561); + Py_CLEAR(clear_module_state->__pyx_codeobj__563); + Py_CLEAR(clear_module_state->__pyx_codeobj__564); + Py_CLEAR(clear_module_state->__pyx_codeobj__565); + Py_CLEAR(clear_module_state->__pyx_codeobj__566); + Py_CLEAR(clear_module_state->__pyx_codeobj__568); + Py_CLEAR(clear_module_state->__pyx_codeobj__569); + Py_CLEAR(clear_module_state->__pyx_codeobj__570); + Py_CLEAR(clear_module_state->__pyx_codeobj__571); + Py_CLEAR(clear_module_state->__pyx_codeobj__573); + Py_CLEAR(clear_module_state->__pyx_codeobj__574); + Py_CLEAR(clear_module_state->__pyx_codeobj__575); + Py_CLEAR(clear_module_state->__pyx_codeobj__576); + Py_CLEAR(clear_module_state->__pyx_codeobj__577); + Py_CLEAR(clear_module_state->__pyx_codeobj__578); + Py_CLEAR(clear_module_state->__pyx_codeobj__579); + Py_CLEAR(clear_module_state->__pyx_codeobj__580); + Py_CLEAR(clear_module_state->__pyx_codeobj__581); + Py_CLEAR(clear_module_state->__pyx_codeobj__582); + Py_CLEAR(clear_module_state->__pyx_codeobj__583); + Py_CLEAR(clear_module_state->__pyx_codeobj__584); + Py_CLEAR(clear_module_state->__pyx_codeobj__585); + Py_CLEAR(clear_module_state->__pyx_codeobj__586); + Py_CLEAR(clear_module_state->__pyx_codeobj__587); + Py_CLEAR(clear_module_state->__pyx_codeobj__588); + Py_CLEAR(clear_module_state->__pyx_codeobj__589); + Py_CLEAR(clear_module_state->__pyx_codeobj__590); + Py_CLEAR(clear_module_state->__pyx_codeobj__591); + Py_CLEAR(clear_module_state->__pyx_codeobj__592); + Py_CLEAR(clear_module_state->__pyx_codeobj__593); + Py_CLEAR(clear_module_state->__pyx_codeobj__594); + Py_CLEAR(clear_module_state->__pyx_codeobj__595); + Py_CLEAR(clear_module_state->__pyx_codeobj__597); + Py_CLEAR(clear_module_state->__pyx_codeobj__598); + Py_CLEAR(clear_module_state->__pyx_codeobj__599); + Py_CLEAR(clear_module_state->__pyx_codeobj__600); + Py_CLEAR(clear_module_state->__pyx_codeobj__601); + Py_CLEAR(clear_module_state->__pyx_codeobj__603); + Py_CLEAR(clear_module_state->__pyx_codeobj__605); + Py_CLEAR(clear_module_state->__pyx_codeobj__606); + Py_CLEAR(clear_module_state->__pyx_codeobj__608); + Py_CLEAR(clear_module_state->__pyx_codeobj__610); + Py_CLEAR(clear_module_state->__pyx_codeobj__612); + Py_CLEAR(clear_module_state->__pyx_codeobj__613); + Py_CLEAR(clear_module_state->__pyx_codeobj__615); + Py_CLEAR(clear_module_state->__pyx_codeobj__616); + Py_CLEAR(clear_module_state->__pyx_codeobj__617); + Py_CLEAR(clear_module_state->__pyx_codeobj__618); + Py_CLEAR(clear_module_state->__pyx_codeobj__619); + Py_CLEAR(clear_module_state->__pyx_codeobj__620); + Py_CLEAR(clear_module_state->__pyx_codeobj__621); + Py_CLEAR(clear_module_state->__pyx_codeobj__622); + Py_CLEAR(clear_module_state->__pyx_codeobj__623); + Py_CLEAR(clear_module_state->__pyx_codeobj__624); + Py_CLEAR(clear_module_state->__pyx_codeobj__625); + Py_CLEAR(clear_module_state->__pyx_codeobj__626); + Py_CLEAR(clear_module_state->__pyx_codeobj__627); + Py_CLEAR(clear_module_state->__pyx_codeobj__628); + Py_CLEAR(clear_module_state->__pyx_codeobj__629); + Py_CLEAR(clear_module_state->__pyx_codeobj__630); + Py_CLEAR(clear_module_state->__pyx_codeobj__631); + Py_CLEAR(clear_module_state->__pyx_codeobj__632); + Py_CLEAR(clear_module_state->__pyx_codeobj__633); + Py_CLEAR(clear_module_state->__pyx_codeobj__634); + Py_CLEAR(clear_module_state->__pyx_codeobj__635); + Py_CLEAR(clear_module_state->__pyx_codeobj__637); + Py_CLEAR(clear_module_state->__pyx_codeobj__638); + Py_CLEAR(clear_module_state->__pyx_codeobj__639); + Py_CLEAR(clear_module_state->__pyx_codeobj__640); + Py_CLEAR(clear_module_state->__pyx_codeobj__641); + Py_CLEAR(clear_module_state->__pyx_codeobj__642); + Py_CLEAR(clear_module_state->__pyx_codeobj__643); + Py_CLEAR(clear_module_state->__pyx_codeobj__645); + Py_CLEAR(clear_module_state->__pyx_codeobj__646); + Py_CLEAR(clear_module_state->__pyx_codeobj__647); + Py_CLEAR(clear_module_state->__pyx_codeobj__648); + Py_CLEAR(clear_module_state->__pyx_codeobj__649); + Py_CLEAR(clear_module_state->__pyx_codeobj__650); + Py_CLEAR(clear_module_state->__pyx_codeobj__652); + Py_CLEAR(clear_module_state->__pyx_codeobj__655); + Py_CLEAR(clear_module_state->__pyx_codeobj__657); + Py_CLEAR(clear_module_state->__pyx_codeobj__658); + Py_CLEAR(clear_module_state->__pyx_codeobj__659); + Py_CLEAR(clear_module_state->__pyx_codeobj__661); + Py_CLEAR(clear_module_state->__pyx_codeobj__662); + Py_CLEAR(clear_module_state->__pyx_codeobj__664); + Py_CLEAR(clear_module_state->__pyx_codeobj__667); + Py_CLEAR(clear_module_state->__pyx_codeobj__669); + Py_CLEAR(clear_module_state->__pyx_codeobj__671); + Py_CLEAR(clear_module_state->__pyx_codeobj__672); + Py_CLEAR(clear_module_state->__pyx_codeobj__673); + Py_CLEAR(clear_module_state->__pyx_codeobj__675); + Py_CLEAR(clear_module_state->__pyx_codeobj__677); + Py_CLEAR(clear_module_state->__pyx_codeobj__678); + Py_CLEAR(clear_module_state->__pyx_codeobj__679); + Py_CLEAR(clear_module_state->__pyx_codeobj__681); + Py_CLEAR(clear_module_state->__pyx_codeobj__683); + Py_CLEAR(clear_module_state->__pyx_codeobj__686); + Py_CLEAR(clear_module_state->__pyx_codeobj__689); + Py_CLEAR(clear_module_state->__pyx_codeobj__691); + Py_CLEAR(clear_module_state->__pyx_codeobj__693); + Py_CLEAR(clear_module_state->__pyx_codeobj__695); + Py_CLEAR(clear_module_state->__pyx_codeobj__697); + Py_CLEAR(clear_module_state->__pyx_codeobj__699); + Py_CLEAR(clear_module_state->__pyx_codeobj__700); + Py_CLEAR(clear_module_state->__pyx_codeobj__701); + Py_CLEAR(clear_module_state->__pyx_codeobj__703); + Py_CLEAR(clear_module_state->__pyx_codeobj__705); + Py_CLEAR(clear_module_state->__pyx_codeobj__706); + Py_CLEAR(clear_module_state->__pyx_codeobj__707); + Py_CLEAR(clear_module_state->__pyx_codeobj__709); + Py_CLEAR(clear_module_state->__pyx_codeobj__711); + Py_CLEAR(clear_module_state->__pyx_codeobj__713); + Py_CLEAR(clear_module_state->__pyx_codeobj__715); + Py_CLEAR(clear_module_state->__pyx_codeobj__717); + Py_CLEAR(clear_module_state->__pyx_codeobj__718); + Py_CLEAR(clear_module_state->__pyx_codeobj__719); + Py_CLEAR(clear_module_state->__pyx_codeobj__721); + Py_CLEAR(clear_module_state->__pyx_codeobj__723); + Py_CLEAR(clear_module_state->__pyx_codeobj__724); + Py_CLEAR(clear_module_state->__pyx_codeobj__725); + Py_CLEAR(clear_module_state->__pyx_codeobj__726); + Py_CLEAR(clear_module_state->__pyx_codeobj__727); + Py_CLEAR(clear_module_state->__pyx_codeobj__728); + Py_CLEAR(clear_module_state->__pyx_codeobj__729); + Py_CLEAR(clear_module_state->__pyx_codeobj__731); + Py_CLEAR(clear_module_state->__pyx_codeobj__732); + Py_CLEAR(clear_module_state->__pyx_codeobj__733); + Py_CLEAR(clear_module_state->__pyx_codeobj__735); + Py_CLEAR(clear_module_state->__pyx_codeobj__736); + Py_CLEAR(clear_module_state->__pyx_codeobj__738); + Py_CLEAR(clear_module_state->__pyx_codeobj__740); + Py_CLEAR(clear_module_state->__pyx_codeobj__741); + Py_CLEAR(clear_module_state->__pyx_codeobj__742); + Py_CLEAR(clear_module_state->__pyx_codeobj__744); + Py_CLEAR(clear_module_state->__pyx_codeobj__746); + Py_CLEAR(clear_module_state->__pyx_codeobj__748); + Py_CLEAR(clear_module_state->__pyx_codeobj__749); + Py_CLEAR(clear_module_state->__pyx_codeobj__751); + Py_CLEAR(clear_module_state->__pyx_codeobj__754); + Py_CLEAR(clear_module_state->__pyx_codeobj__755); + Py_CLEAR(clear_module_state->__pyx_codeobj__756); + Py_CLEAR(clear_module_state->__pyx_codeobj__757); + Py_CLEAR(clear_module_state->__pyx_codeobj__758); + Py_CLEAR(clear_module_state->__pyx_codeobj__759); + Py_CLEAR(clear_module_state->__pyx_codeobj__761); + Py_CLEAR(clear_module_state->__pyx_codeobj__762); + Py_CLEAR(clear_module_state->__pyx_codeobj__763); + Py_CLEAR(clear_module_state->__pyx_codeobj__764); + Py_CLEAR(clear_module_state->__pyx_codeobj__766); + Py_CLEAR(clear_module_state->__pyx_codeobj__768); + Py_CLEAR(clear_module_state->__pyx_codeobj__769); + Py_CLEAR(clear_module_state->__pyx_codeobj__771); + Py_CLEAR(clear_module_state->__pyx_codeobj__773); + Py_CLEAR(clear_module_state->__pyx_codeobj__774); + Py_CLEAR(clear_module_state->__pyx_codeobj__776); + Py_CLEAR(clear_module_state->__pyx_codeobj__777); + Py_CLEAR(clear_module_state->__pyx_codeobj__778); + Py_CLEAR(clear_module_state->__pyx_codeobj__779); + Py_CLEAR(clear_module_state->__pyx_codeobj__781); + Py_CLEAR(clear_module_state->__pyx_codeobj__784); + Py_CLEAR(clear_module_state->__pyx_codeobj__786); + Py_CLEAR(clear_module_state->__pyx_codeobj__788); + Py_CLEAR(clear_module_state->__pyx_codeobj__790); + Py_CLEAR(clear_module_state->__pyx_codeobj__792); + Py_CLEAR(clear_module_state->__pyx_codeobj__795); + Py_CLEAR(clear_module_state->__pyx_codeobj__797); + Py_CLEAR(clear_module_state->__pyx_codeobj__799); + Py_CLEAR(clear_module_state->__pyx_codeobj__802); + Py_CLEAR(clear_module_state->__pyx_codeobj__804); + Py_CLEAR(clear_module_state->__pyx_codeobj__806); + Py_CLEAR(clear_module_state->__pyx_codeobj__807); + Py_CLEAR(clear_module_state->__pyx_codeobj__809); + Py_CLEAR(clear_module_state->__pyx_codeobj__811); + Py_CLEAR(clear_module_state->__pyx_codeobj__813); + Py_CLEAR(clear_module_state->__pyx_codeobj__815); + Py_CLEAR(clear_module_state->__pyx_codeobj__817); + Py_CLEAR(clear_module_state->__pyx_codeobj__819); + Py_CLEAR(clear_module_state->__pyx_codeobj__822); + Py_CLEAR(clear_module_state->__pyx_codeobj__824); + Py_CLEAR(clear_module_state->__pyx_codeobj__827); + Py_CLEAR(clear_module_state->__pyx_codeobj__830); + Py_CLEAR(clear_module_state->__pyx_codeobj__833); + Py_CLEAR(clear_module_state->__pyx_codeobj__836); + Py_CLEAR(clear_module_state->__pyx_codeobj__838); + Py_CLEAR(clear_module_state->__pyx_codeobj__840); + Py_CLEAR(clear_module_state->__pyx_codeobj__841); + Py_CLEAR(clear_module_state->__pyx_codeobj__842); + Py_CLEAR(clear_module_state->__pyx_codeobj__843); + Py_CLEAR(clear_module_state->__pyx_codeobj__845); + Py_CLEAR(clear_module_state->__pyx_codeobj__847); + Py_CLEAR(clear_module_state->__pyx_codeobj__849); + Py_CLEAR(clear_module_state->__pyx_codeobj__851); + Py_CLEAR(clear_module_state->__pyx_codeobj__853); + Py_CLEAR(clear_module_state->__pyx_codeobj__855); + Py_CLEAR(clear_module_state->__pyx_codeobj__857); + Py_CLEAR(clear_module_state->__pyx_codeobj__858); + Py_CLEAR(clear_module_state->__pyx_codeobj__860); + Py_CLEAR(clear_module_state->__pyx_codeobj__861); + Py_CLEAR(clear_module_state->__pyx_codeobj__862); + Py_CLEAR(clear_module_state->__pyx_codeobj__864); + Py_CLEAR(clear_module_state->__pyx_codeobj__866); + Py_CLEAR(clear_module_state->__pyx_codeobj__868); + Py_CLEAR(clear_module_state->__pyx_codeobj__869); + Py_CLEAR(clear_module_state->__pyx_codeobj__870); + Py_CLEAR(clear_module_state->__pyx_codeobj__872); + Py_CLEAR(clear_module_state->__pyx_codeobj__874); + Py_CLEAR(clear_module_state->__pyx_codeobj__876); + Py_CLEAR(clear_module_state->__pyx_codeobj__878); + Py_CLEAR(clear_module_state->__pyx_codeobj__880); + Py_CLEAR(clear_module_state->__pyx_codeobj__882); + Py_CLEAR(clear_module_state->__pyx_codeobj__884); + Py_CLEAR(clear_module_state->__pyx_codeobj__886); + Py_CLEAR(clear_module_state->__pyx_codeobj__888); + Py_CLEAR(clear_module_state->__pyx_codeobj__889); + Py_CLEAR(clear_module_state->__pyx_codeobj__890); + Py_CLEAR(clear_module_state->__pyx_codeobj__891); + Py_CLEAR(clear_module_state->__pyx_codeobj__893); + Py_CLEAR(clear_module_state->__pyx_codeobj__895); + Py_CLEAR(clear_module_state->__pyx_codeobj__897); + Py_CLEAR(clear_module_state->__pyx_codeobj__898); + Py_CLEAR(clear_module_state->__pyx_codeobj__899); + Py_CLEAR(clear_module_state->__pyx_codeobj__901); + Py_CLEAR(clear_module_state->__pyx_codeobj__903); + Py_CLEAR(clear_module_state->__pyx_codeobj__904); + Py_CLEAR(clear_module_state->__pyx_codeobj__905); + Py_CLEAR(clear_module_state->__pyx_codeobj__906); + Py_CLEAR(clear_module_state->__pyx_codeobj__908); + Py_CLEAR(clear_module_state->__pyx_codeobj__910); + Py_CLEAR(clear_module_state->__pyx_codeobj__912); + Py_CLEAR(clear_module_state->__pyx_codeobj__914); + Py_CLEAR(clear_module_state->__pyx_codeobj__916); + Py_CLEAR(clear_module_state->__pyx_codeobj__918); + Py_CLEAR(clear_module_state->__pyx_codeobj__920); + Py_CLEAR(clear_module_state->__pyx_codeobj__922); + Py_CLEAR(clear_module_state->__pyx_codeobj__924); + Py_CLEAR(clear_module_state->__pyx_codeobj__926); + Py_CLEAR(clear_module_state->__pyx_codeobj__928); + Py_CLEAR(clear_module_state->__pyx_codeobj__931); + Py_CLEAR(clear_module_state->__pyx_codeobj__933); + Py_CLEAR(clear_module_state->__pyx_codeobj__935); + Py_CLEAR(clear_module_state->__pyx_codeobj__937); + Py_CLEAR(clear_module_state->__pyx_codeobj__939); + Py_CLEAR(clear_module_state->__pyx_codeobj__942); + Py_CLEAR(clear_module_state->__pyx_codeobj__944); + Py_CLEAR(clear_module_state->__pyx_codeobj__947); + Py_CLEAR(clear_module_state->__pyx_codeobj__949); + Py_CLEAR(clear_module_state->__pyx_codeobj__952); + Py_CLEAR(clear_module_state->__pyx_codeobj__954); + Py_CLEAR(clear_module_state->__pyx_codeobj__956); + Py_CLEAR(clear_module_state->__pyx_codeobj__958); + Py_CLEAR(clear_module_state->__pyx_codeobj__961); + Py_CLEAR(clear_module_state->__pyx_codeobj__963); + Py_CLEAR(clear_module_state->__pyx_codeobj__965); + Py_CLEAR(clear_module_state->__pyx_codeobj__967); + Py_CLEAR(clear_module_state->__pyx_codeobj__970); + Py_CLEAR(clear_module_state->__pyx_codeobj__972); + Py_CLEAR(clear_module_state->__pyx_codeobj__974); + Py_CLEAR(clear_module_state->__pyx_codeobj__976); + Py_CLEAR(clear_module_state->__pyx_codeobj__978); + Py_CLEAR(clear_module_state->__pyx_codeobj__980); + Py_CLEAR(clear_module_state->__pyx_codeobj__982); + Py_CLEAR(clear_module_state->__pyx_codeobj__984); + Py_CLEAR(clear_module_state->__pyx_codeobj__985); + Py_CLEAR(clear_module_state->__pyx_codeobj__986); + Py_CLEAR(clear_module_state->__pyx_codeobj__988); + Py_CLEAR(clear_module_state->__pyx_codeobj__990); + Py_CLEAR(clear_module_state->__pyx_codeobj__991); + Py_CLEAR(clear_module_state->__pyx_codeobj__992); + Py_CLEAR(clear_module_state->__pyx_codeobj__993); + Py_CLEAR(clear_module_state->__pyx_codeobj__995); + Py_CLEAR(clear_module_state->__pyx_codeobj__997); + Py_CLEAR(clear_module_state->__pyx_codeobj__998); + Py_CLEAR(clear_module_state->__pyx_codeobj__1000); + Py_CLEAR(clear_module_state->__pyx_codeobj__1002); + Py_CLEAR(clear_module_state->__pyx_codeobj__1003); + Py_CLEAR(clear_module_state->__pyx_codeobj__1004); + Py_CLEAR(clear_module_state->__pyx_codeobj__1005); + Py_CLEAR(clear_module_state->__pyx_codeobj__1007); + Py_CLEAR(clear_module_state->__pyx_codeobj__1008); + Py_CLEAR(clear_module_state->__pyx_codeobj__1009); + Py_CLEAR(clear_module_state->__pyx_codeobj__1010); + Py_CLEAR(clear_module_state->__pyx_codeobj__1011); + Py_CLEAR(clear_module_state->__pyx_codeobj__1013); + Py_CLEAR(clear_module_state->__pyx_codeobj__1014); + Py_CLEAR(clear_module_state->__pyx_codeobj__1015); + Py_CLEAR(clear_module_state->__pyx_codeobj__1016); + Py_CLEAR(clear_module_state->__pyx_codeobj__1017); + Py_CLEAR(clear_module_state->__pyx_codeobj__1019); + Py_CLEAR(clear_module_state->__pyx_codeobj__1020); + Py_CLEAR(clear_module_state->__pyx_codeobj__1021); + Py_CLEAR(clear_module_state->__pyx_codeobj__1023); + Py_CLEAR(clear_module_state->__pyx_codeobj__1026); + Py_CLEAR(clear_module_state->__pyx_codeobj__1028); + Py_CLEAR(clear_module_state->__pyx_codeobj__1029); + Py_CLEAR(clear_module_state->__pyx_codeobj__1031); + Py_CLEAR(clear_module_state->__pyx_codeobj__1033); + Py_CLEAR(clear_module_state->__pyx_codeobj__1036); + Py_CLEAR(clear_module_state->__pyx_codeobj__1038); + Py_CLEAR(clear_module_state->__pyx_codeobj__1041); + Py_CLEAR(clear_module_state->__pyx_codeobj__1042); + Py_CLEAR(clear_module_state->__pyx_codeobj__1043); + Py_CLEAR(clear_module_state->__pyx_codeobj__1045); + Py_CLEAR(clear_module_state->__pyx_codeobj__1047); + Py_CLEAR(clear_module_state->__pyx_codeobj__1049); + Py_CLEAR(clear_module_state->__pyx_codeobj__1052); + Py_CLEAR(clear_module_state->__pyx_codeobj__1055); + Py_CLEAR(clear_module_state->__pyx_codeobj__1056); + Py_CLEAR(clear_module_state->__pyx_codeobj__1057); + Py_CLEAR(clear_module_state->__pyx_codeobj__1058); + Py_CLEAR(clear_module_state->__pyx_codeobj__1059); + Py_CLEAR(clear_module_state->__pyx_codeobj__1060); + Py_CLEAR(clear_module_state->__pyx_codeobj__1062); + Py_CLEAR(clear_module_state->__pyx_codeobj__1063); + Py_CLEAR(clear_module_state->__pyx_codeobj__1065); + Py_CLEAR(clear_module_state->__pyx_codeobj__1067); + Py_CLEAR(clear_module_state->__pyx_codeobj__1068); + Py_CLEAR(clear_module_state->__pyx_codeobj__1070); + Py_CLEAR(clear_module_state->__pyx_codeobj__1072); + Py_CLEAR(clear_module_state->__pyx_codeobj__1073); + Py_CLEAR(clear_module_state->__pyx_codeobj__1074); + Py_CLEAR(clear_module_state->__pyx_codeobj__1076); + Py_CLEAR(clear_module_state->__pyx_codeobj__1077); + Py_CLEAR(clear_module_state->__pyx_codeobj__1078); + Py_CLEAR(clear_module_state->__pyx_codeobj__1079); + Py_CLEAR(clear_module_state->__pyx_codeobj__1081); + Py_CLEAR(clear_module_state->__pyx_codeobj__1082); + Py_CLEAR(clear_module_state->__pyx_codeobj__1083); + Py_CLEAR(clear_module_state->__pyx_codeobj__1084); + Py_CLEAR(clear_module_state->__pyx_codeobj__1085); + Py_CLEAR(clear_module_state->__pyx_codeobj__1087); + Py_CLEAR(clear_module_state->__pyx_codeobj__1089); + Py_CLEAR(clear_module_state->__pyx_codeobj__1090); + Py_CLEAR(clear_module_state->__pyx_codeobj__1092); + Py_CLEAR(clear_module_state->__pyx_codeobj__1093); + Py_CLEAR(clear_module_state->__pyx_codeobj__1095); + Py_CLEAR(clear_module_state->__pyx_codeobj__1096); + Py_CLEAR(clear_module_state->__pyx_codeobj__1097); + Py_CLEAR(clear_module_state->__pyx_codeobj__1099); + Py_CLEAR(clear_module_state->__pyx_codeobj__1101); + Py_CLEAR(clear_module_state->__pyx_codeobj__1103); + Py_CLEAR(clear_module_state->__pyx_codeobj__1105); + Py_CLEAR(clear_module_state->__pyx_codeobj__1107); + Py_CLEAR(clear_module_state->__pyx_codeobj__1109); + Py_CLEAR(clear_module_state->__pyx_codeobj__1110); + Py_CLEAR(clear_module_state->__pyx_codeobj__1111); + Py_CLEAR(clear_module_state->__pyx_codeobj__1112); + Py_CLEAR(clear_module_state->__pyx_codeobj__1113); + Py_CLEAR(clear_module_state->__pyx_codeobj__1115); + Py_CLEAR(clear_module_state->__pyx_codeobj__1117); + Py_CLEAR(clear_module_state->__pyx_codeobj__1119); + Py_CLEAR(clear_module_state->__pyx_codeobj__1121); + Py_CLEAR(clear_module_state->__pyx_codeobj__1123); + Py_CLEAR(clear_module_state->__pyx_codeobj__1125); + Py_CLEAR(clear_module_state->__pyx_codeobj__1127); + Py_CLEAR(clear_module_state->__pyx_codeobj__1129); + Py_CLEAR(clear_module_state->__pyx_codeobj__1130); + Py_CLEAR(clear_module_state->__pyx_codeobj__1132); + Py_CLEAR(clear_module_state->__pyx_codeobj__1134); + Py_CLEAR(clear_module_state->__pyx_codeobj__1135); + Py_CLEAR(clear_module_state->__pyx_codeobj__1136); + Py_CLEAR(clear_module_state->__pyx_codeobj__1138); + Py_CLEAR(clear_module_state->__pyx_codeobj__1139); + Py_CLEAR(clear_module_state->__pyx_codeobj__1140); + Py_CLEAR(clear_module_state->__pyx_codeobj__1142); + Py_CLEAR(clear_module_state->__pyx_codeobj__1145); + Py_CLEAR(clear_module_state->__pyx_codeobj__1146); + Py_CLEAR(clear_module_state->__pyx_codeobj__1147); + Py_CLEAR(clear_module_state->__pyx_codeobj__1148); + Py_CLEAR(clear_module_state->__pyx_codeobj__1149); + Py_CLEAR(clear_module_state->__pyx_codeobj__1150); + Py_CLEAR(clear_module_state->__pyx_codeobj__1152); + Py_CLEAR(clear_module_state->__pyx_codeobj__1153); + Py_CLEAR(clear_module_state->__pyx_codeobj__1154); + Py_CLEAR(clear_module_state->__pyx_codeobj__1155); + Py_CLEAR(clear_module_state->__pyx_codeobj__1156); + Py_CLEAR(clear_module_state->__pyx_codeobj__1157); + Py_CLEAR(clear_module_state->__pyx_codeobj__1158); + Py_CLEAR(clear_module_state->__pyx_codeobj__1159); + Py_CLEAR(clear_module_state->__pyx_codeobj__1160); + Py_CLEAR(clear_module_state->__pyx_codeobj__1161); + Py_CLEAR(clear_module_state->__pyx_codeobj__1162); + Py_CLEAR(clear_module_state->__pyx_codeobj__1163); + Py_CLEAR(clear_module_state->__pyx_codeobj__1164); + Py_CLEAR(clear_module_state->__pyx_codeobj__1165); + Py_CLEAR(clear_module_state->__pyx_codeobj__1166); + Py_CLEAR(clear_module_state->__pyx_codeobj__1167); + Py_CLEAR(clear_module_state->__pyx_codeobj__1168); + Py_CLEAR(clear_module_state->__pyx_codeobj__1169); + Py_CLEAR(clear_module_state->__pyx_codeobj__1170); + Py_CLEAR(clear_module_state->__pyx_codeobj__1171); + Py_CLEAR(clear_module_state->__pyx_codeobj__1172); + Py_CLEAR(clear_module_state->__pyx_codeobj__1173); + Py_CLEAR(clear_module_state->__pyx_codeobj__1174); + Py_CLEAR(clear_module_state->__pyx_codeobj__1175); + Py_CLEAR(clear_module_state->__pyx_codeobj__1176); + Py_CLEAR(clear_module_state->__pyx_codeobj__1177); + Py_CLEAR(clear_module_state->__pyx_codeobj__1178); + Py_CLEAR(clear_module_state->__pyx_codeobj__1179); + Py_CLEAR(clear_module_state->__pyx_codeobj__1180); + Py_CLEAR(clear_module_state->__pyx_codeobj__1181); + Py_CLEAR(clear_module_state->__pyx_codeobj__1182); + Py_CLEAR(clear_module_state->__pyx_codeobj__1183); + Py_CLEAR(clear_module_state->__pyx_codeobj__1184); + Py_CLEAR(clear_module_state->__pyx_codeobj__1185); + Py_CLEAR(clear_module_state->__pyx_codeobj__1186); + Py_CLEAR(clear_module_state->__pyx_codeobj__1187); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4bool_bool); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_7complex_complex); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Expr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Expr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Event); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Event); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Column); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Column); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Row); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Row); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_NLRow); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_NLRow); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Solution); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Solution); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_DomainChanges); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_DomainChanges); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_BoundChange); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_BoundChange); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Node); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Node); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Variable); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Variable); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Constraint); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Constraint); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Model); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Model); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_ExprCons); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_ExprCons); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_GenExpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_GenExpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_SumExpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_SumExpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_ProdExpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_ProdExpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_VarExpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_VarExpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PowExpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PowExpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_UnaryExpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_UnaryExpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Constant); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Constant); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_LP); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_LP); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Benders); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Benders); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Benderscut); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Benderscut); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Branchrule); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Branchrule); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Conshdlr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Conshdlr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Cutsel); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Cutsel); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Eventhdlr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Eventhdlr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Heur); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Heur); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Presol); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Presol); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Pricer); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Pricer); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Prop); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Prop); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Sepa); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Sepa); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Reader); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Reader); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Relax); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Relax); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_Nodesel); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_Nodesel); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem__); + Py_VISIT(traverse_module_state->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_AFTERLPLOOP); + Py_VISIT(traverse_module_state->__pyx_n_s_AFTERLPNODE); + Py_VISIT(traverse_module_state->__pyx_n_s_AFTERLPPLUNGE); + Py_VISIT(traverse_module_state->__pyx_n_s_AFTERPROPLOOP); + Py_VISIT(traverse_module_state->__pyx_n_s_AFTERPSEUDONODE); + Py_VISIT(traverse_module_state->__pyx_n_s_AFTERPSEUDOPLUNGE); + Py_VISIT(traverse_module_state->__pyx_n_s_AGGRESSIVE); + Py_VISIT(traverse_module_state->__pyx_n_u_ANDcons); + Py_VISIT(traverse_module_state->__pyx_n_s_AUTO); + Py_VISIT(traverse_module_state->__pyx_n_s_AssertionError); + Py_VISIT(traverse_module_state->__pyx_n_u_B); + Py_VISIT(traverse_module_state->__pyx_n_s_BEFORELP); + Py_VISIT(traverse_module_state->__pyx_n_s_BEFORENODE); + Py_VISIT(traverse_module_state->__pyx_n_s_BEFOREPRESOL); + Py_VISIT(traverse_module_state->__pyx_n_s_BENCHMARK); + Py_VISIT(traverse_module_state->__pyx_n_s_BESTSOLFOUND); + Py_VISIT(traverse_module_state->__pyx_n_s_BESTSOLLIMIT); + Py_VISIT(traverse_module_state->__pyx_n_u_BINARY); + Py_VISIT(traverse_module_state->__pyx_n_s_BOUNDCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_BOUNDRELAXED); + Py_VISIT(traverse_module_state->__pyx_n_s_BOUNDTIGHTENED); + Py_VISIT(traverse_module_state->__pyx_n_s_BRANCHED); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_benderscreatesub); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersexitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersfreesub); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersgetvar); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersinitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_bendersinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_benderspostsolve); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_benderspresubsolve); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_benderssolvesub); + Py_VISIT(traverse_module_state->__pyx_n_s_Benders_benderssolvesubconvex); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut_benderscutexec); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut_benderscutexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut_benderscutexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut_benderscutfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut_benderscutinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Benderscut_benderscutinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_BoundChange); + Py_VISIT(traverse_module_state->__pyx_n_s_BoundChange___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_BoundChange___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_BoundChange_getBoundchgtype); + Py_VISIT(traverse_module_state->__pyx_n_s_BoundChange_getBoundtype); + Py_VISIT(traverse_module_state->__pyx_n_s_BoundChange_getNewBound); + Py_VISIT(traverse_module_state->__pyx_n_s_BoundChange_getVar); + Py_VISIT(traverse_module_state->__pyx_n_s_BoundChange_isRedundant); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule_branchexecext); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule_branchexeclp); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule_branchexecps); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule_branchexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule_branchexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule_branchfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule_branchinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Branchrule_branchinitsol); + Py_VISIT(traverse_module_state->__pyx_n_u_C); + Py_VISIT(traverse_module_state->__pyx_n_s_CHECK); + Py_VISIT(traverse_module_state->__pyx_n_s_CHILD); + Py_VISIT(traverse_module_state->__pyx_n_s_CONS); + Py_VISIT(traverse_module_state->__pyx_n_s_CONSADDED); + Py_VISIT(traverse_module_state->__pyx_n_s_CONSCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_CONST); + Py_VISIT(traverse_module_state->__pyx_n_u_CONTINUOUS); + Py_VISIT(traverse_module_state->__pyx_n_s_COUNTER); + Py_VISIT(traverse_module_state->__pyx_n_s_CPSOLVER); + Py_VISIT(traverse_module_state->__pyx_n_s_CUTOFF); + Py_VISIT(traverse_module_state->__pyx_kp_u_Can_only_support_constraints_wit); + Py_VISIT(traverse_module_state->__pyx_kp_u_Can_t_evaluate_constraints_as_bo); + Py_VISIT(traverse_module_state->__pyx_kp_u_Cannot_set_value_to_a_freed_solu); + Py_VISIT(traverse_module_state->__pyx_n_u_CardinalityCons); + Py_VISIT(traverse_module_state->__pyx_n_s_Column); + Py_VISIT(traverse_module_state->__pyx_n_s_Column___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Column___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Column_getBasisStatus); + Py_VISIT(traverse_module_state->__pyx_n_s_Column_getLPPos); + Py_VISIT(traverse_module_state->__pyx_n_s_Column_getLb); + Py_VISIT(traverse_module_state->__pyx_n_s_Column_getObjCoeff); + Py_VISIT(traverse_module_state->__pyx_n_s_Column_getPrimsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Column_getUb); + Py_VISIT(traverse_module_state->__pyx_n_s_Column_getVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Column_isIntegral); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consactive); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_conscheck); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_conscopy); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consdeactive); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consdelete); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consdelvars); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consdisable); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consenable); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consenfolp); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consenfops); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consenforelax); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consexitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consgetdivebdchgs); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consgetnvars); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consgetpermsymgraph); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consgetsignedpermsymgra); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consgetvars); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consinitlp); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consinitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_conslock); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consparse); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_conspresol); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consprint); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consprop); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_consresprop); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_conssepalp); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_conssepasol); + Py_VISIT(traverse_module_state->__pyx_n_s_Conshdlr_constrans); + Py_VISIT(traverse_module_state->__pyx_n_s_Constant); + Py_VISIT(traverse_module_state->__pyx_n_s_Constant___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Constant___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_u_Constant_offsets_in_objective_ar); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_getConshdlrName); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isActive); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isChecked); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isDynamic); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isEnforced); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isInitial); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isModifiable); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isOriginal); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isPropagated); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isRemovable); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isSeparated); + Py_VISIT(traverse_module_state->__pyx_n_s_Constraint_isStickingAtNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel_cutselexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel_cutselexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel_cutselfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel_cutselinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel_cutselinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Cutsel_cutselselect); + Py_VISIT(traverse_module_state->__pyx_n_s_DEADEND); + Py_VISIT(traverse_module_state->__pyx_n_s_DEFAULT); + Py_VISIT(traverse_module_state->__pyx_n_s_DELAYED); + Py_VISIT(traverse_module_state->__pyx_n_s_DIDNOTFIND); + Py_VISIT(traverse_module_state->__pyx_n_s_DIDNOTRUN); + Py_VISIT(traverse_module_state->__pyx_n_s_DISABLED); + Py_VISIT(traverse_module_state->__pyx_n_s_DOMCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_DOWNWARDS); + Py_VISIT(traverse_module_state->__pyx_n_s_DUALLIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_DURINGLPLOOP); + Py_VISIT(traverse_module_state->__pyx_n_s_DURINGPRESOLLOOP); + Py_VISIT(traverse_module_state->__pyx_n_s_DURINGPRICINGLOOP); + Py_VISIT(traverse_module_state->__pyx_n_s_DomainChanges); + Py_VISIT(traverse_module_state->__pyx_n_s_DomainChanges___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_DomainChanges___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_DomainChanges_getBoundchgs); + Py_VISIT(traverse_module_state->__pyx_n_s_EASYCIP); + Py_VISIT(traverse_module_state->__pyx_n_s_ERROR); + Py_VISIT(traverse_module_state->__pyx_n_s_EXHAUSTIVE); + Py_VISIT(traverse_module_state->__pyx_n_s_EXITPRESOLVE); + Py_VISIT(traverse_module_state->__pyx_n_s_EXITSOLVE); + Py_VISIT(traverse_module_state->__pyx_n_s_Event); + Py_VISIT(traverse_module_state->__pyx_n_s_EventNames); + Py_VISIT(traverse_module_state->__pyx_n_s_Event___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Event___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Event__getEventNames); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_getName); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_getNewBound); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_getNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_getOldBound); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_getRow); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_getType); + Py_VISIT(traverse_module_state->__pyx_n_s_Event_getVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr_eventcopy); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr_eventdelete); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr_eventexec); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr_eventexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr_eventexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr_eventfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr_eventinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Eventhdlr_eventinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Expr); + Py_VISIT(traverse_module_state->__pyx_kp_u_ExprCons); + Py_VISIT(traverse_module_state->__pyx_n_s_ExprCons_2); + Py_VISIT(traverse_module_state->__pyx_n_s_ExprCons___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ExprCons___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_kp_u_ExprCons_already_has_lower_bound); + Py_VISIT(traverse_module_state->__pyx_kp_u_ExprCons_already_has_upper_bound); + Py_VISIT(traverse_module_state->__pyx_n_s_ExprCons_normalize); + Py_VISIT(traverse_module_state->__pyx_n_s_Expr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Expr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Expr_degree); + Py_VISIT(traverse_module_state->__pyx_n_s_Expr_normalize); + Py_VISIT(traverse_module_state->__pyx_kp_u_Expr_s); + Py_VISIT(traverse_module_state->__pyx_n_s_FAST); + Py_VISIT(traverse_module_state->__pyx_n_s_FEASIBILITY); + Py_VISIT(traverse_module_state->__pyx_n_s_FEASIBLE); + Py_VISIT(traverse_module_state->__pyx_n_s_FIRSTLPSOLVED); + Py_VISIT(traverse_module_state->__pyx_n_s_FIXED); + Py_VISIT(traverse_module_state->__pyx_n_s_FOCUSNODE); + Py_VISIT(traverse_module_state->__pyx_n_s_FORK); + Py_VISIT(traverse_module_state->__pyx_n_s_FOUNDSOL); + Py_VISIT(traverse_module_state->__pyx_n_s_FREE); + Py_VISIT(traverse_module_state->__pyx_n_s_FREETRANS); + Py_VISIT(traverse_module_state->__pyx_n_s_GAPLIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_GBDCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_GHOLEADDED); + Py_VISIT(traverse_module_state->__pyx_n_s_GHOLECHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_GHOLEREMOVED); + Py_VISIT(traverse_module_state->__pyx_n_s_GLBCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_GUBCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_GenExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_GenExpr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_GenExpr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_GenExpr_degree); + Py_VISIT(traverse_module_state->__pyx_n_s_GenExpr_getOp); + Py_VISIT(traverse_module_state->__pyx_kp_u_Given_constraint_list_is_not_ite); + Py_VISIT(traverse_module_state->__pyx_kp_u_Given_constraint_list_is_not_ite_2); + Py_VISIT(traverse_module_state->__pyx_n_s_HARDLP); + Py_VISIT(traverse_module_state->__pyx_n_s_HOLECHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur_heurexec); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur_heurexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur_heurexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur_heurfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur_heurinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Heur_heurinitsol); + Py_VISIT(traverse_module_state->__pyx_n_u_I); + Py_VISIT(traverse_module_state->__pyx_n_s_IMPLADDED); + Py_VISIT(traverse_module_state->__pyx_n_u_IMPLINT); + Py_VISIT(traverse_module_state->__pyx_n_s_INFEASIBLE); + Py_VISIT(traverse_module_state->__pyx_n_s_INFORUNBD); + Py_VISIT(traverse_module_state->__pyx_n_s_INIT); + Py_VISIT(traverse_module_state->__pyx_n_s_INITPRESOLVE); + Py_VISIT(traverse_module_state->__pyx_n_s_INITSOLVE); + Py_VISIT(traverse_module_state->__pyx_n_u_INTEGER); + Py_VISIT(traverse_module_state->__pyx_n_s_IOError); + Py_VISIT(traverse_module_state->__pyx_n_s_ITERLIMIT); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_7); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_8); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_9); + Py_VISIT(traverse_module_state->__pyx_n_u_IndicatorCons); + Py_VISIT(traverse_module_state->__pyx_n_s_Iterable); + Py_VISIT(traverse_module_state->__pyx_n_s_JUNCTION); + Py_VISIT(traverse_module_state->__pyx_n_s_KeyError); + Py_VISIT(traverse_module_state->__pyx_n_s_LBCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_LBRELAXED); + Py_VISIT(traverse_module_state->__pyx_n_s_LBTIGHTENED); + Py_VISIT(traverse_module_state->__pyx_n_s_LC_NUMERIC); + Py_VISIT(traverse_module_state->__pyx_n_s_LEAF); + Py_VISIT(traverse_module_state->__pyx_n_s_LHOLEADDED); + Py_VISIT(traverse_module_state->__pyx_n_s_LHOLECHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_LHOLEREMOVED); + Py_VISIT(traverse_module_state->__pyx_n_s_LP); + Py_VISIT(traverse_module_state->__pyx_n_u_LP); + Py_VISIT(traverse_module_state->__pyx_n_s_LPEVENT); + Py_VISIT(traverse_module_state->__pyx_n_s_LPSOLVED); + Py_VISIT(traverse_module_state->__pyx_n_s_LP___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_LP___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_addCol); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_addCols); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_addRow); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_addRows); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_chgBound); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_chgCoef); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_chgObj); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_chgSide); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_clear); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_delCols); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_delRows); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getBasisInds); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getBounds); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getDual); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getDualRay); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getNIterations); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getPrimal); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getPrimalRay); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getRedcost); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_getSides); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_infinity); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_isDualFeasible); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_isInfinity); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_isPrimalFeasible); + Py_VISIT(traverse_module_state->__pyx_kp_u_LP_lp); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_ncols); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_nrows); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_readLP); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_solve); + Py_VISIT(traverse_module_state->__pyx_n_s_LP_writeLP); + Py_VISIT(traverse_module_state->__pyx_n_s_LookupError); + Py_VISIT(traverse_module_state->__pyx_n_u_M); + Py_VISIT(traverse_module_state->__pyx_n_s_MAJOR); + Py_VISIT(traverse_module_state->__pyx_n_s_MEDIUM); + Py_VISIT(traverse_module_state->__pyx_n_s_MEMLIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_MINOR); + Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); + Py_VISIT(traverse_module_state->__pyx_n_s_Model); + Py_VISIT(traverse_module_state->__pyx_n_s_Model___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Model___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Model__createConsGenNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model__createConsLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model__createConsNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model__createConsQuadratic); + Py_VISIT(traverse_module_state->__pyx_n_s_Model__getStageNames); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_activateBenders); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addBendersSubproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addCoefLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addCons); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsAnd); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsCardinality); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsCoeff); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsDisjunction); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsElemDisjunction); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsIndicator); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsOr); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsSOS1); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsSOS2); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConsXor); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addConss); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addCut); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addExprNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addObjoffset); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addPoolCut); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addPyCons); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addRowDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addVarLocks); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addVarSOS1); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addVarSOS2); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_addVarToRow); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_appendVarSOS1); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_appendVarSOS2); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_applyCutsProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_backtrackProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_branchVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_branchVarVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_cacheRowExtensions); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_calcChildEstimate); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_calcNodeselPriority); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_catchEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_catchRowEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_catchVarEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_checkBendersSubproblemOpti); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_checkQuadraticNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_checkSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgCoefLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgLhs); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgReoptObjective); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgRhs); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgRowLhsDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgRowRhsDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarBranchPriority); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarLb); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarLbDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarLbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarLbNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarLbProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarObjDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarObjProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarType); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarUb); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarUbDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarUbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarUbNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_chgVarUbProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_computeBestSolSubproblems); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_constructLP); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_count); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createChild); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createCons); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createConsFromExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createEmptyRowSepa); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createEmptyRowUnspec); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createOrigSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createPartialSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createProbBasic); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_createSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_delCoefLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_delCons); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_delConsLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_delVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_disablePropagation); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_dropEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_dropRowEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_dropVarEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_enableReoptimization); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_endDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_endProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_epsilon); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_feasFrac); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_feastol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_fixVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_fixVarProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_flushRowExtensions); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_frac); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_freeBendersSubproblems); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_freeProb); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_freeReoptSolve); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_freeSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_freeTransform); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_from_ptr); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getActivity); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBendersAuxiliaryVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBendersSubproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBendersVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBestChild); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBestLeaf); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBestNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBestSibling); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBestSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getBestboundNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getCondition); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getConsNVars); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getConsVars); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getConss); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getCurrentNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getCutEfficacy); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getCutLPSolCutoffDistance); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getDepth); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getDualMultiplier); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getDualSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getDualbound); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getDualboundRoot); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getDualfarkasLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getDualsolLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getGap); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLPBInvARow); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLPBInvRow); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLPBasisInd); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLPBranchCands); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLPColsData); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLPObjVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLPRowsData); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLPSolstat); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLhs); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getLocalEstimate); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNBestSolsFound); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNBinVars); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNChildren); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNConss); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNCountedSols); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNCuts); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNCutsApplied); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNFeasibleLeaves); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNInfeasibleLeaves); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNIntVars); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNLPCols); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNLPIterations); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNLPRows); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNLPs); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNLeaves); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNLimSolsFound); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNNlRows); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNNodes); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNReaders); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNSepaRounds); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNSiblings); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNSols); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNSolsFound); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNTotalNodes); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNVars); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNlRowActivityBounds); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNlRowSolActivity); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNlRowSolFeasibility); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getNlRows); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getObjVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getObjective); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getObjectiveSense); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getObjlimit); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getObjoffset); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getOpenNodes); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getParams); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getPresolvingTime); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getPrimalRay); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getPrimalRayVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getPrimalbound); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getProbName); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getProbingDepth); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getPseudoBranchCands); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getReadingTime); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getRhs); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getRowActivity); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getRowDualSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getRowLPActivity); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getRowLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getRowNumIntCols); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getRowObjParallelism); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getRowParallelism); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getSlack); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getSlackVarIndicator); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getSolObjVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getSolTime); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getSols); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getSolvingTime); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getStage); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getStageName); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getStatus); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getTermsQuadratic); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getTotalTime); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getTransformedCons); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getTransformedVar); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getTreesizeEstimation); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getValsLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getVarDict); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getVarLbDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getVarRedcost); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getVarUbDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_getVars); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_hasPrimalRay); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_hideOutput); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_inProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_inRepropagation); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeBenders); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeBendersDefaultCuts); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeBenderscut); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeBranchrule); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeConshdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeCutsel); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeDefaultPlugins); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeEventhdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeHeur); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeNodesel); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includePresol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includePricer); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeProp); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeReader); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeRelax); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_includeSepa); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_infinity); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_initBendersDefault); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_interruptSolve); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isCutEfficacious); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isEQ); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isFeasEQ); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isFeasIntegral); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isFeasNegative); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isFeasZero); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isGE); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isGT); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isInfinity); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isLE); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isLPSolBasic); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isLT); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isNLPConstructed); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isObjChangedProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_isZero); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_lpiGetIterations); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_newProbingNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_optimize); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_presolve); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_printBestSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_printCons); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_printExternalCodeVersions); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_printNlRow); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_printRow); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_printSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_printStatistics); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_printVersion); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_propagateProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_readParams); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_readProblem); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_readSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_readSolFile); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_redirectOutput); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_relax); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_releaseRow); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_repropagateNode); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_resetParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_resetParams); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_restartSolve); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_separateSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setBendersSubproblemIsConv); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setBoolParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setCharParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setCheck); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setEmphasis); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setEnforced); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setHeuristics); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setInitial); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setIntParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setLogfile); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setLongintParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setMaximize); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setMinimize); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setObjIntegral); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setObjective); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setObjlimit); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setParams); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setParamsCountsols); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setPresolve); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setProbName); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setRealParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setRelaxSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setRemovable); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setSeparating); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setStringParam); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_setupBendersSubproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_solveBendersSubproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_solveConcurrent); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_solveDiveLP); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_solveProbingLP); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_startDive); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_startProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_tightenVarLb); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_tightenVarLbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_tightenVarUb); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_tightenVarUbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_to_ptr); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_trySol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_updateBendersLowerbounds); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_updateNodeLowerbound); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_version); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeBestSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeBestTransSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeLP); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeName); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeParams); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeProblem); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeStatistics); + Py_VISIT(traverse_module_state->__pyx_n_s_Model_writeTransSol); + Py_VISIT(traverse_module_state->__pyx_n_s_NEWROUND); + Py_VISIT(traverse_module_state->__pyx_n_s_NLRow); + Py_VISIT(traverse_module_state->__pyx_n_s_NLRow___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_NLRow___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_NLRow_getConstant); + Py_VISIT(traverse_module_state->__pyx_n_s_NLRow_getDualsol); + Py_VISIT(traverse_module_state->__pyx_n_s_NLRow_getLhs); + Py_VISIT(traverse_module_state->__pyx_n_s_NLRow_getLinearTerms); + Py_VISIT(traverse_module_state->__pyx_n_s_NLRow_getRhs); + Py_VISIT(traverse_module_state->__pyx_n_s_NODEBRANCHED); + Py_VISIT(traverse_module_state->__pyx_n_s_NODEDELETE); + Py_VISIT(traverse_module_state->__pyx_n_s_NODEEVENT); + Py_VISIT(traverse_module_state->__pyx_n_s_NODEFEASIBLE); + Py_VISIT(traverse_module_state->__pyx_n_s_NODEFOCUSED); + Py_VISIT(traverse_module_state->__pyx_n_s_NODEINFEASIBLE); + Py_VISIT(traverse_module_state->__pyx_n_s_NODELIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_NODESOLVED); + Py_VISIT(traverse_module_state->__pyx_n_s_NONE); + Py_VISIT(traverse_module_state->__pyx_n_s_NOTSOLVED); + Py_VISIT(traverse_module_state->__pyx_n_s_NUMERICS); + Py_VISIT(traverse_module_state->__pyx_n_s_Node); + Py_VISIT(traverse_module_state->__pyx_n_s_Node___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Node___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getAddedConss); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getDepth); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getDomchg); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getEstimate); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getLowerbound); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getNAddedConss); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getNDomchg); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getNParentBranchings); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getNumber); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getParent); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getParentBranchings); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_getType); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_isActive); + Py_VISIT(traverse_module_state->__pyx_n_s_Node_isPropagatedAgain); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel_nodecomp); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel_nodeexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel_nodeexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel_nodefree); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel_nodeinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel_nodeinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Nodesel_nodeselect); + Py_VISIT(traverse_module_state->__pyx_kp_u_Nonlinear_objective_functions_ar); + Py_VISIT(traverse_module_state->__pyx_n_s_NotImplementedError); + Py_VISIT(traverse_module_state->__pyx_kp_u_Not_a_valid_parameter_name); + Py_VISIT(traverse_module_state->__pyx_n_s_OBJCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_OBJLIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_OFF); + Py_VISIT(traverse_module_state->__pyx_n_s_OPTIMAL); + Py_VISIT(traverse_module_state->__pyx_n_s_OPTIMALITY); + Py_VISIT(traverse_module_state->__pyx_n_u_ORcons); + Py_VISIT(traverse_module_state->__pyx_n_s_Op); + Py_VISIT(traverse_module_state->__pyx_n_s_Operator); + Py_VISIT(traverse_module_state->__pyx_n_s_PATCH); + Py_VISIT(traverse_module_state->__pyx_n_s_PHASEFEAS); + Py_VISIT(traverse_module_state->__pyx_n_s_PHASEIMPROVE); + Py_VISIT(traverse_module_state->__pyx_n_s_PHASEPROOF); + Py_VISIT(traverse_module_state->__pyx_n_s_POORSOLFOUND); + Py_VISIT(traverse_module_state->__pyx_n_s_PRESOLVED); + Py_VISIT(traverse_module_state->__pyx_n_s_PRESOLVEROUND); + Py_VISIT(traverse_module_state->__pyx_n_s_PRESOLVING); + Py_VISIT(traverse_module_state->__pyx_n_s_PRIMALLIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_PROBINGNODE); + Py_VISIT(traverse_module_state->__pyx_n_s_PROBLEM); + Py_VISIT(traverse_module_state->__pyx_n_s_PSEUDO); + Py_VISIT(traverse_module_state->__pyx_n_s_PSEUDOFORK); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___setsta); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_BRANCHDIR); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_BRANCHDIR___reduce_cytho); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_BRANCHDIR___setstate_cyt); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_CALL); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_EVENTTYPE); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_EVENTTYPE___reduce_cytho); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_EVENTTYPE___setstate_cyt); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_HEURTIMING); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_HEURTIMING___reduce_cyth); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_HEURTIMING___setstate_cy); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_LPSOLSTAT); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_LPSOLSTAT___reduce_cytho); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_LPSOLSTAT___setstate_cyt); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_NODETYPE); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_NODETYPE___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_NODETYPE___setstate_cyth); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PARAMEMPHASIS); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PARAMEMPHASIS___reduce_c); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PARAMEMPHASIS___setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PARAMSETTING); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PARAMSETTING___reduce_cy); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PARAMSETTING___setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PRESOLTIMING); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PRESOLTIMING___reduce_cy); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PRESOLTIMING___setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PROPTIMING); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PROPTIMING___reduce_cyth); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_PROPTIMING___setstate_cy); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_RESULT); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_RESULT___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_RESULT___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_ROWORIGINTYPE); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_ROWORIGINTYPE___reduce_c); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_ROWORIGINTYPE___setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_STAGE); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_STAGE___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_STAGE___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_STATUS); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_STATUS___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PY_SCIP_STATUS___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_PowExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_PowExpr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_PowExpr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol_presolexec); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol_presolexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol_presolexitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol_presolfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol_presolinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Presol_presolinitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer_pricerexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer_pricerexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer_pricerfarkas); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer_pricerfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer_pricerinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer_pricerinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Pricer_pricerredcost); + Py_VISIT(traverse_module_state->__pyx_n_s_ProdExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_ProdExpr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ProdExpr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propexec); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propexitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propinitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_proppresol); + Py_VISIT(traverse_module_state->__pyx_n_s_Prop_propresprop); + Py_VISIT(traverse_module_state->__pyx_kp_u_Provide_BOOLEAN_value_as_rhsvar); + Py_VISIT(traverse_module_state->__pyx_n_s_PyCons); + Py_VISIT(traverse_module_state->__pyx_n_s_PyRow); + Py_VISIT(traverse_module_state->__pyx_n_s_REDUCEDDOM); + Py_VISIT(traverse_module_state->__pyx_n_s_REFOCUSNODE); + Py_VISIT(traverse_module_state->__pyx_n_s_RELAX); + Py_VISIT(traverse_module_state->__pyx_n_s_REOPT); + Py_VISIT(traverse_module_state->__pyx_n_s_RESTARTLIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWADDEDLP); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWADDEDSEPA); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWCOEFCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWCONSTCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWDELETEDLP); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWDELETEDSEPA); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWEVENT); + Py_VISIT(traverse_module_state->__pyx_n_s_ROWSIDECHANGED); + Py_VISIT(traverse_module_state->__pyx_kp_u_Ranged_ExprCons_is_not_well_defi); + Py_VISIT(traverse_module_state->__pyx_n_s_Reader); + Py_VISIT(traverse_module_state->__pyx_n_s_Reader___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Reader___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Reader_readerfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Reader_readerread); + Py_VISIT(traverse_module_state->__pyx_n_s_Reader_readerwrite); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax_relaxexec); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax_relaxexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax_relaxexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax_relaxfree); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax_relaxinit); + Py_VISIT(traverse_module_state->__pyx_n_s_Relax_relaxinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Row); + Py_VISIT(traverse_module_state->__pyx_n_s_Row___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Row___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getBasisStatus); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getCols); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getConsOriginConshdlrtype); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getConstant); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getLPPos); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getLhs); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getNLPNonz); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getNNonz); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getNorm); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getOrigintype); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getRhs); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_getVals); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_isInGlobalCutpool); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_isIntegral); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_isLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_isModifiable); + Py_VISIT(traverse_module_state->__pyx_n_s_Row_isRemovable); + Py_VISIT(traverse_module_state->__pyx_n_s_SCIP_BOUNDTYPE_TO_STRING); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_a_required_plugin_was_not_f); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_cannot_create_file); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_does_not_support_nonlinear); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_error_in_LP_solver); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_error_in_input_data); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_file_not_found_error); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_insufficient_memory_error); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_maximal_branching_depth_lev); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_method_cannot_be_called_at); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_method_returned_an_invalid); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_no_problem_exists); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_read_error); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_reading_solution_from_file); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_returned_base_status_zero_f); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_returned_unknown_base_statu); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_the_given_key_is_already_ex); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_the_parameter_is_not_of_the); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_the_parameter_with_the_give); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_the_value_is_invalid_for_th); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_unknown_return_code); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_unspecified_error); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_was_compiled_without_task_p); + Py_VISIT(traverse_module_state->__pyx_kp_u_SCIP_write_error); + Py_VISIT(traverse_module_state->__pyx_n_u_SCIPgetSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_SEPA); + Py_VISIT(traverse_module_state->__pyx_n_s_SEPARATED); + Py_VISIT(traverse_module_state->__pyx_n_s_SIBLING); + Py_VISIT(traverse_module_state->__pyx_n_s_SOLEVENT); + Py_VISIT(traverse_module_state->__pyx_n_s_SOLFOUND); + Py_VISIT(traverse_module_state->__pyx_n_s_SOLLIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_SOLVED); + Py_VISIT(traverse_module_state->__pyx_n_s_SOLVELP); + Py_VISIT(traverse_module_state->__pyx_n_s_SOLVING); + Py_VISIT(traverse_module_state->__pyx_n_u_SOS1cons); + Py_VISIT(traverse_module_state->__pyx_n_u_SOS2cons); + Py_VISIT(traverse_module_state->__pyx_n_s_STALLNODELIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_SUBROOT); + Py_VISIT(traverse_module_state->__pyx_n_s_SUCCESS); + Py_VISIT(traverse_module_state->__pyx_n_s_SUSPENDED); + Py_VISIT(traverse_module_state->__pyx_n_s_SYNC); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa_sepaexeclp); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa_sepaexecsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa_sepaexit); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa_sepaexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa_sepafree); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa_sepainit); + Py_VISIT(traverse_module_state->__pyx_n_s_Sepa_sepainitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_Solution); + Py_VISIT(traverse_module_state->__pyx_n_s_Solution___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Solution___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Solution__checkStage); + Py_VISIT(traverse_module_state->__pyx_n_s_Solution__evaluate); + Py_VISIT(traverse_module_state->__pyx_n_s_StageNames); + Py_VISIT(traverse_module_state->__pyx_n_s_StopIteration); + Py_VISIT(traverse_module_state->__pyx_n_s_SumExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_SumExpr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_SumExpr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_TIMELIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_TOTALNODELIMIT); + Py_VISIT(traverse_module_state->__pyx_n_s_TRANSFORMED); + Py_VISIT(traverse_module_state->__pyx_n_s_TRANSFORMING); + Py_VISIT(traverse_module_state->__pyx_n_s_Term); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___add); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___eq); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___getitem); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___hash); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___init); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___init___locals_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___init___locals_lambda); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___len); + Py_VISIT(traverse_module_state->__pyx_n_s_Term___repr); + Py_VISIT(traverse_module_state->__pyx_kp_u_Term_s); + Py_VISIT(traverse_module_state->__pyx_kp_u_The_constraint_handler_s_does_no); + Py_VISIT(traverse_module_state->__pyx_kp_u_The_given_capsule_does_not_conta); + Py_VISIT(traverse_module_state->__pyx_kp_u_The_given_variable_is_not_a_pyva); + Py_VISIT(traverse_module_state->__pyx_kp_u_The_problem_does_not_have_a_prim); + Py_VISIT(traverse_module_state->__pyx_kp_s_This_is_a_monomial_term); + Py_VISIT(traverse_module_state->__pyx_kp_u_To_create_a_solution_you_should); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s_UBCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_UBRELAXED); + Py_VISIT(traverse_module_state->__pyx_n_s_UBTIGHTENED); + Py_VISIT(traverse_module_state->__pyx_n_s_UNBOUNDED); + Py_VISIT(traverse_module_state->__pyx_n_s_UNBOUNDEDRAY); + Py_VISIT(traverse_module_state->__pyx_n_s_UNKNOWN); + Py_VISIT(traverse_module_state->__pyx_n_s_UNSPEC); + Py_VISIT(traverse_module_state->__pyx_n_s_UPWARDS); + Py_VISIT(traverse_module_state->__pyx_n_s_USERINTERRUPT); + Py_VISIT(traverse_module_state->__pyx_n_s_UnaryExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_UnaryExpr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_UnaryExpr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Union); + Py_VISIT(traverse_module_state->__pyx_kp_s_Union_Expr_GenExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_VARADDED); + Py_VISIT(traverse_module_state->__pyx_n_s_VARCHANGED); + Py_VISIT(traverse_module_state->__pyx_n_s_VARDELETED); + Py_VISIT(traverse_module_state->__pyx_n_s_VAREVENT); + Py_VISIT(traverse_module_state->__pyx_n_s_VARFIXED); + Py_VISIT(traverse_module_state->__pyx_n_s_VARUNLOCKED); + Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); + Py_VISIT(traverse_module_state->__pyx_n_s_VarExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_VarExpr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_VarExpr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getCol); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getIndex); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getLPSol); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getLbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getLbLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getLbOriginal); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getObj); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getUbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getUbLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_getUbOriginal); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_isInLP); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_isOriginal); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_ptr); + Py_VISIT(traverse_module_state->__pyx_n_s_Variable_vtype); + Py_VISIT(traverse_module_state->__pyx_n_s_Warning); + Py_VISIT(traverse_module_state->__pyx_n_u_XORcons); + Py_VISIT(traverse_module_state->__pyx_n_s_ZeroDivisionError); + Py_VISIT(traverse_module_state->__pyx_kp_u__10); + Py_VISIT(traverse_module_state->__pyx_kp_u__114); + Py_VISIT(traverse_module_state->__pyx_n_s__1188); + Py_VISIT(traverse_module_state->__pyx_n_s__126); + Py_VISIT(traverse_module_state->__pyx_kp_u__126); + Py_VISIT(traverse_module_state->__pyx_kp_u__162); + Py_VISIT(traverse_module_state->__pyx_kp_u__163); + Py_VISIT(traverse_module_state->__pyx_kp_u__164); + Py_VISIT(traverse_module_state->__pyx_kp_u__165); + Py_VISIT(traverse_module_state->__pyx_kp_u__2); + Py_VISIT(traverse_module_state->__pyx_kp_u__441); + Py_VISIT(traverse_module_state->__pyx_kp_u__442); + Py_VISIT(traverse_module_state->__pyx_kp_u__6); + Py_VISIT(traverse_module_state->__pyx_kp_u__79); + Py_VISIT(traverse_module_state->__pyx_kp_u__89); + Py_VISIT(traverse_module_state->__pyx_kp_u__9); + Py_VISIT(traverse_module_state->__pyx_n_u__94); + Py_VISIT(traverse_module_state->__pyx_n_u_abs); + Py_VISIT(traverse_module_state->__pyx_n_s_absfile); + Py_VISIT(traverse_module_state->__pyx_n_s_abspath); + Py_VISIT(traverse_module_state->__pyx_n_s_activateBenders); + Py_VISIT(traverse_module_state->__pyx_n_s_activeone); + Py_VISIT(traverse_module_state->__pyx_n_s_activity); + Py_VISIT(traverse_module_state->__pyx_n_s_add); + Py_VISIT(traverse_module_state->__pyx_n_s_addBendersSubproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_addCoefLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_addCol); + Py_VISIT(traverse_module_state->__pyx_n_s_addCols); + Py_VISIT(traverse_module_state->__pyx_n_s_addCols_locals_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_addCons); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsAnd); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsCardinality); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsCoeff); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsDisjunction); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsDisjunction_locals_ensure); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsElemDisjunction); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsIndicator); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsNode); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsOr); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsSOS1); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsSOS2); + Py_VISIT(traverse_module_state->__pyx_n_s_addConsXor); + Py_VISIT(traverse_module_state->__pyx_n_s_addConss); + Py_VISIT(traverse_module_state->__pyx_n_s_addConss_locals_ensure_iterable); + Py_VISIT(traverse_module_state->__pyx_n_s_addCut); + Py_VISIT(traverse_module_state->__pyx_n_s_addExprNonlinear); + Py_VISIT(traverse_module_state->__pyx_kp_u_addExprNonlinear_can_only_be_cal); + Py_VISIT(traverse_module_state->__pyx_kp_u_addExprNonlinear_cannot_be_calle); + Py_VISIT(traverse_module_state->__pyx_n_s_addObjoffset); + Py_VISIT(traverse_module_state->__pyx_n_s_addPoolCut); + Py_VISIT(traverse_module_state->__pyx_n_s_addPyCons); + Py_VISIT(traverse_module_state->__pyx_n_s_addRow); + Py_VISIT(traverse_module_state->__pyx_n_s_addRowDive); + Py_VISIT(traverse_module_state->__pyx_n_s_addRows); + Py_VISIT(traverse_module_state->__pyx_n_s_addRows_locals_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_addSol); + Py_VISIT(traverse_module_state->__pyx_n_s_addVar); + Py_VISIT(traverse_module_state->__pyx_n_s_addVarLocks); + Py_VISIT(traverse_module_state->__pyx_n_s_addVarSOS1); + Py_VISIT(traverse_module_state->__pyx_n_s_addVarSOS2); + Py_VISIT(traverse_module_state->__pyx_n_s_addVarToRow); + Py_VISIT(traverse_module_state->__pyx_n_s_add_2); + Py_VISIT(traverse_module_state->__pyx_n_s_addedconss); + Py_VISIT(traverse_module_state->__pyx_n_s_addedconsssize); + Py_VISIT(traverse_module_state->__pyx_n_s_allowaddcons); + Py_VISIT(traverse_module_state->__pyx_n_s_allowlocal); + Py_VISIT(traverse_module_state->__pyx_n_s_append); + Py_VISIT(traverse_module_state->__pyx_n_s_appendVarSOS1); + Py_VISIT(traverse_module_state->__pyx_n_s_appendVarSOS2); + Py_VISIT(traverse_module_state->__pyx_n_s_applyCutsProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_args); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_attr); + Py_VISIT(traverse_module_state->__pyx_n_s_auxvar); + Py_VISIT(traverse_module_state->__pyx_n_s_auxvar_2); + Py_VISIT(traverse_module_state->__pyx_n_u_auxviol); + Py_VISIT(traverse_module_state->__pyx_n_s_backtrackProbing); + Py_VISIT(traverse_module_state->__pyx_n_u_basic); + Py_VISIT(traverse_module_state->__pyx_n_s_bdtype); + Py_VISIT(traverse_module_state->__pyx_n_s_beg); + Py_VISIT(traverse_module_state->__pyx_n_s_benders); + Py_VISIT(traverse_module_state->__pyx_n_s_benders_2); + Py_VISIT(traverse_module_state->__pyx_n_s_benderscreatesub); + Py_VISIT(traverse_module_state->__pyx_n_s_benderscut); + Py_VISIT(traverse_module_state->__pyx_n_s_benderscutexec); + Py_VISIT(traverse_module_state->__pyx_n_s_benderscutexit); + Py_VISIT(traverse_module_state->__pyx_n_s_benderscutexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_benderscutfree); + Py_VISIT(traverse_module_state->__pyx_n_s_benderscutinit); + Py_VISIT(traverse_module_state->__pyx_n_s_benderscutinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersexit); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersexitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersfree); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersfreesub); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersgetvar); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersinit); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersinitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_bendersinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_benderspostsolve); + Py_VISIT(traverse_module_state->__pyx_n_s_benderspresubsolve); + Py_VISIT(traverse_module_state->__pyx_n_s_benderssolvesub); + Py_VISIT(traverse_module_state->__pyx_n_s_benderssolvesubconvex); + Py_VISIT(traverse_module_state->__pyx_n_u_bestsollimit); + Py_VISIT(traverse_module_state->__pyx_n_s_bilincoef); + Py_VISIT(traverse_module_state->__pyx_n_s_bilinterm1); + Py_VISIT(traverse_module_state->__pyx_n_s_bilinterm2); + Py_VISIT(traverse_module_state->__pyx_n_s_bilinterms); + Py_VISIT(traverse_module_state->__pyx_n_s_binVar); + Py_VISIT(traverse_module_state->__pyx_n_s_binds); + Py_VISIT(traverse_module_state->__pyx_n_s_binvar); + Py_VISIT(traverse_module_state->__pyx_n_s_binvars); + Py_VISIT(traverse_module_state->__pyx_n_s_both); + Py_VISIT(traverse_module_state->__pyx_n_s_boundconstraint); + Py_VISIT(traverse_module_state->__pyx_n_s_bounded); + Py_VISIT(traverse_module_state->__pyx_n_s_boundtypes); + Py_VISIT(traverse_module_state->__pyx_n_s_branchVar); + Py_VISIT(traverse_module_state->__pyx_n_s_branchVarVal); + Py_VISIT(traverse_module_state->__pyx_n_s_branchbounds); + Py_VISIT(traverse_module_state->__pyx_n_s_branchdir); + Py_VISIT(traverse_module_state->__pyx_n_s_branchexecext); + Py_VISIT(traverse_module_state->__pyx_kp_u_branchexecext_is_a_fundamental_c); + Py_VISIT(traverse_module_state->__pyx_n_s_branchexeclp); + Py_VISIT(traverse_module_state->__pyx_kp_u_branchexeclp_is_a_fundamental_ca); + Py_VISIT(traverse_module_state->__pyx_n_s_branchexecps); + Py_VISIT(traverse_module_state->__pyx_kp_u_branchexecps_is_a_fundamental_ca); + Py_VISIT(traverse_module_state->__pyx_n_s_branchexit); + Py_VISIT(traverse_module_state->__pyx_n_s_branchexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_branchfree); + Py_VISIT(traverse_module_state->__pyx_n_s_branchinit); + Py_VISIT(traverse_module_state->__pyx_n_s_branchinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_branchrule); + Py_VISIT(traverse_module_state->__pyx_n_s_branchvars); + Py_VISIT(traverse_module_state->__pyx_n_s_buildGenExprObj); + Py_VISIT(traverse_module_state->__pyx_n_s_c); + Py_VISIT(traverse_module_state->__pyx_n_u_c); + Py_VISIT(traverse_module_state->__pyx_n_s_c_beg); + Py_VISIT(traverse_module_state->__pyx_n_s_c_binds); + Py_VISIT(traverse_module_state->__pyx_n_s_c_coefs); + Py_VISIT(traverse_module_state->__pyx_n_s_c_col); + Py_VISIT(traverse_module_state->__pyx_n_s_c_dualsol); + Py_VISIT(traverse_module_state->__pyx_n_s_c_inds); + Py_VISIT(traverse_module_state->__pyx_n_s_c_lb); + Py_VISIT(traverse_module_state->__pyx_n_s_c_lbs); + Py_VISIT(traverse_module_state->__pyx_n_s_c_lhs); + Py_VISIT(traverse_module_state->__pyx_n_s_c_lhss); + Py_VISIT(traverse_module_state->__pyx_n_s_c_obj); + Py_VISIT(traverse_module_state->__pyx_n_s_c_objs); + Py_VISIT(traverse_module_state->__pyx_n_s_c_path); + Py_VISIT(traverse_module_state->__pyx_n_s_c_primalsol); + Py_VISIT(traverse_module_state->__pyx_n_s_c_ray); + Py_VISIT(traverse_module_state->__pyx_n_s_c_redcost); + Py_VISIT(traverse_module_state->__pyx_n_s_c_rhs); + Py_VISIT(traverse_module_state->__pyx_n_s_c_rhss); + Py_VISIT(traverse_module_state->__pyx_n_s_c_row); + Py_VISIT(traverse_module_state->__pyx_n_s_c_ub); + Py_VISIT(traverse_module_state->__pyx_n_s_c_ubs); + Py_VISIT(traverse_module_state->__pyx_n_s_cacheRowExtensions); + Py_VISIT(traverse_module_state->__pyx_n_s_calcChildEstimate); + Py_VISIT(traverse_module_state->__pyx_n_s_calcNodeselPriority); + Py_VISIT(traverse_module_state->__pyx_kp_u_can_only_be_called_with_a_valid); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_BoundChange_with_S); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_Column_with_SCIP_C); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_Constraint_with_SC); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_DomainChanges_with); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_Event_with_SCIP_EV); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_Model_with_SCIP_NU); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_NLRow_with_SCIP_NL); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_Row_with_SCIP_ROW); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_Solution_with_SCIP); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_create_Variable_with_SCIP); + Py_VISIT(traverse_module_state->__pyx_kp_u_cannot_divide_by_0); + Py_VISIT(traverse_module_state->__pyx_n_s_capsule); + Py_VISIT(traverse_module_state->__pyx_n_s_cardval); + Py_VISIT(traverse_module_state->__pyx_n_s_catchEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_catchRowEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_catchVarEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_category); + Py_VISIT(traverse_module_state->__pyx_n_s_cfile); + Py_VISIT(traverse_module_state->__pyx_n_s_chckpriority); + Py_VISIT(traverse_module_state->__pyx_n_s_check); + Py_VISIT(traverse_module_state->__pyx_n_u_check); + Py_VISIT(traverse_module_state->__pyx_n_s_checkBendersSubproblemOptimality); + Py_VISIT(traverse_module_state->__pyx_n_s_checkQuadraticNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_checkSol); + Py_VISIT(traverse_module_state->__pyx_n_s_checkStage); + Py_VISIT(traverse_module_state->__pyx_n_s_checkbounds); + Py_VISIT(traverse_module_state->__pyx_n_s_checkint); + Py_VISIT(traverse_module_state->__pyx_n_s_checkintegrality); + Py_VISIT(traverse_module_state->__pyx_n_s_checklprows); + Py_VISIT(traverse_module_state->__pyx_n_s_checktype); + Py_VISIT(traverse_module_state->__pyx_n_s_chgBound); + Py_VISIT(traverse_module_state->__pyx_n_s_chgCoef); + Py_VISIT(traverse_module_state->__pyx_n_s_chgCoefLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_chgLhs); + Py_VISIT(traverse_module_state->__pyx_n_s_chgObj); + Py_VISIT(traverse_module_state->__pyx_n_s_chgReoptObjective); + Py_VISIT(traverse_module_state->__pyx_n_s_chgRhs); + Py_VISIT(traverse_module_state->__pyx_n_s_chgRowLhsDive); + Py_VISIT(traverse_module_state->__pyx_n_s_chgRowRhsDive); + Py_VISIT(traverse_module_state->__pyx_n_s_chgSide); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarBranchPriority); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarLb); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarLbDive); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarLbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarLbNode); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarLbProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarObjDive); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarObjProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarType); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarUb); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarUbDive); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarUbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarUbNode); + Py_VISIT(traverse_module_state->__pyx_n_s_chgVarUbProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_child); + Py_VISIT(traverse_module_state->__pyx_n_s_children); + Py_VISIT(traverse_module_state->__pyx_n_s_children_2); + Py_VISIT(traverse_module_state->__pyx_n_s_childrenexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_chr); + Py_VISIT(traverse_module_state->__pyx_kp_u_cip); + Py_VISIT(traverse_module_state->__pyx_n_s_class); + Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); + Py_VISIT(traverse_module_state->__pyx_n_s_clear); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_close); + Py_VISIT(traverse_module_state->__pyx_n_s_closefd); + Py_VISIT(traverse_module_state->__pyx_n_s_cname); + Py_VISIT(traverse_module_state->__pyx_n_s_coef); + Py_VISIT(traverse_module_state->__pyx_n_s_coeff); + Py_VISIT(traverse_module_state->__pyx_kp_u_coefficients_not_available_for_c); + Py_VISIT(traverse_module_state->__pyx_n_s_coeffs); + Py_VISIT(traverse_module_state->__pyx_n_s_coeffs_2); + Py_VISIT(traverse_module_state->__pyx_n_s_coeffs_array); + Py_VISIT(traverse_module_state->__pyx_n_s_coefs); + Py_VISIT(traverse_module_state->__pyx_n_s_col); + Py_VISIT(traverse_module_state->__pyx_n_s_collections_abc); + Py_VISIT(traverse_module_state->__pyx_n_s_cols); + Py_VISIT(traverse_module_state->__pyx_n_s_comments); + Py_VISIT(traverse_module_state->__pyx_n_s_completely); + Py_VISIT(traverse_module_state->__pyx_n_s_computeBestSolSubproblems); + Py_VISIT(traverse_module_state->__pyx_n_s_confvar); + Py_VISIT(traverse_module_state->__pyx_n_s_cons); + Py_VISIT(traverse_module_state->__pyx_n_s_consactive); + Py_VISIT(traverse_module_state->__pyx_n_s_conscheck); + Py_VISIT(traverse_module_state->__pyx_n_s_conscopy); + Py_VISIT(traverse_module_state->__pyx_n_s_consdeactive); + Py_VISIT(traverse_module_state->__pyx_n_s_consdelete); + Py_VISIT(traverse_module_state->__pyx_n_s_consdelvars); + Py_VISIT(traverse_module_state->__pyx_n_s_consdisable); + Py_VISIT(traverse_module_state->__pyx_n_s_consenable); + Py_VISIT(traverse_module_state->__pyx_n_s_consenfolp); + Py_VISIT(traverse_module_state->__pyx_n_s_consenfops); + Py_VISIT(traverse_module_state->__pyx_n_s_consenforelax); + Py_VISIT(traverse_module_state->__pyx_n_s_consexit); + Py_VISIT(traverse_module_state->__pyx_n_s_consexitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_consexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_consfree); + Py_VISIT(traverse_module_state->__pyx_n_s_consgetdivebdchgs); + Py_VISIT(traverse_module_state->__pyx_n_s_consgetnvars); + Py_VISIT(traverse_module_state->__pyx_n_s_consgetpermsymgraph); + Py_VISIT(traverse_module_state->__pyx_n_s_consgetsignedpermsymgraph); + Py_VISIT(traverse_module_state->__pyx_n_s_consgetvars); + Py_VISIT(traverse_module_state->__pyx_n_s_conshdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_conshdrlname); + Py_VISIT(traverse_module_state->__pyx_n_s_consinit); + Py_VISIT(traverse_module_state->__pyx_n_s_consinitlp); + Py_VISIT(traverse_module_state->__pyx_n_s_consinitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_consinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_conslock); + Py_VISIT(traverse_module_state->__pyx_n_s_consparse); + Py_VISIT(traverse_module_state->__pyx_n_s_conspresol); + Py_VISIT(traverse_module_state->__pyx_n_s_consprint); + Py_VISIT(traverse_module_state->__pyx_n_s_consprop); + Py_VISIT(traverse_module_state->__pyx_n_s_consresprop); + Py_VISIT(traverse_module_state->__pyx_n_s_conss); + Py_VISIT(traverse_module_state->__pyx_n_s_conss_2); + Py_VISIT(traverse_module_state->__pyx_n_s_conssepalp); + Py_VISIT(traverse_module_state->__pyx_n_s_conssepasol); + Py_VISIT(traverse_module_state->__pyx_n_s_const); + Py_VISIT(traverse_module_state->__pyx_n_u_const); + Py_VISIT(traverse_module_state->__pyx_n_s_constant); + Py_VISIT(traverse_module_state->__pyx_n_s_constraint); + Py_VISIT(traverse_module_state->__pyx_kp_u_constraint_is_not_nonlinear); + Py_VISIT(traverse_module_state->__pyx_kp_u_constraint_is_not_quadratic); + Py_VISIT(traverse_module_state->__pyx_n_s_constraints); + Py_VISIT(traverse_module_state->__pyx_kp_u_constraints_benders_active); + Py_VISIT(traverse_module_state->__pyx_kp_u_constraints_benderslp_active); + Py_VISIT(traverse_module_state->__pyx_n_s_constrans); + Py_VISIT(traverse_module_state->__pyx_n_s_constructLP); + Py_VISIT(traverse_module_state->__pyx_n_s_constype); + Py_VISIT(traverse_module_state->__pyx_n_s_consvars); + Py_VISIT(traverse_module_state->__pyx_n_s_contvars); + Py_VISIT(traverse_module_state->__pyx_n_s_copy); + Py_VISIT(traverse_module_state->__pyx_n_s_cos); + Py_VISIT(traverse_module_state->__pyx_n_u_cos); + Py_VISIT(traverse_module_state->__pyx_kp_u_could_not_change_variable_type_o); + Py_VISIT(traverse_module_state->__pyx_n_s_count); + Py_VISIT(traverse_module_state->__pyx_n_s_createChild); + Py_VISIT(traverse_module_state->__pyx_n_s_createCons); + Py_VISIT(traverse_module_state->__pyx_n_s_createConsFromExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_createConsGenNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_createConsLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_createConsNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_createConsQuadratic); + Py_VISIT(traverse_module_state->__pyx_n_s_createEmptyRowSepa); + Py_VISIT(traverse_module_state->__pyx_n_s_createEmptyRowUnspec); + Py_VISIT(traverse_module_state->__pyx_n_s_createOrigSol); + Py_VISIT(traverse_module_state->__pyx_n_s_createPartialSol); + Py_VISIT(traverse_module_state->__pyx_n_s_createProbBasic); + Py_VISIT(traverse_module_state->__pyx_n_s_createSol); + Py_VISIT(traverse_module_state->__pyx_n_s_createscip); + Py_VISIT(traverse_module_state->__pyx_n_s_cut); + Py_VISIT(traverse_module_state->__pyx_n_s_cutlp); + Py_VISIT(traverse_module_state->__pyx_n_s_cutoff); + Py_VISIT(traverse_module_state->__pyx_n_s_cutpseudo); + Py_VISIT(traverse_module_state->__pyx_n_s_cutrelax); + Py_VISIT(traverse_module_state->__pyx_n_s_cuts); + Py_VISIT(traverse_module_state->__pyx_n_u_cuts); + Py_VISIT(traverse_module_state->__pyx_n_s_cutsel); + Py_VISIT(traverse_module_state->__pyx_n_s_cutselexit); + Py_VISIT(traverse_module_state->__pyx_n_s_cutselexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_cutselfree); + Py_VISIT(traverse_module_state->__pyx_n_s_cutselinit); + Py_VISIT(traverse_module_state->__pyx_n_s_cutselinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_cutselselect); + Py_VISIT(traverse_module_state->__pyx_n_s_d); + Py_VISIT(traverse_module_state->__pyx_n_s_defaultPlugins); + Py_VISIT(traverse_module_state->__pyx_n_s_deg); + Py_VISIT(traverse_module_state->__pyx_n_s_degree); + Py_VISIT(traverse_module_state->__pyx_n_s_degree_locals_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_delCoefLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_delCols); + Py_VISIT(traverse_module_state->__pyx_n_s_delCons); + Py_VISIT(traverse_module_state->__pyx_n_s_delConsLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_delRows); + Py_VISIT(traverse_module_state->__pyx_n_s_delVar); + Py_VISIT(traverse_module_state->__pyx_n_s_delay); + Py_VISIT(traverse_module_state->__pyx_n_s_delayed); + Py_VISIT(traverse_module_state->__pyx_n_s_delayprop); + Py_VISIT(traverse_module_state->__pyx_n_s_delaysepa); + Py_VISIT(traverse_module_state->__pyx_n_s_deleted); + Py_VISIT(traverse_module_state->__pyx_n_s_des); + Py_VISIT(traverse_module_state->__pyx_n_s_desc); + Py_VISIT(traverse_module_state->__pyx_n_s_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_dict_2); + Py_VISIT(traverse_module_state->__pyx_n_s_dis); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_n_s_disablePropagation); + Py_VISIT(traverse_module_state->__pyx_n_s_disj_cons); + Py_VISIT(traverse_module_state->__pyx_n_s_dispchar); + Py_VISIT(traverse_module_state->__pyx_n_s_div); + Py_VISIT(traverse_module_state->__pyx_n_s_doc); + Py_VISIT(traverse_module_state->__pyx_n_s_domchg); + Py_VISIT(traverse_module_state->__pyx_n_s_downchild); + Py_VISIT(traverse_module_state->__pyx_n_s_dropEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_dropRowEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_dropVarEvent); + Py_VISIT(traverse_module_state->__pyx_n_s_dual); + Py_VISIT(traverse_module_state->__pyx_kp_u_dual_solution_values_not_availab); + Py_VISIT(traverse_module_state->__pyx_n_u_duallimit); + Py_VISIT(traverse_module_state->__pyx_n_s_dualsol); + Py_VISIT(traverse_module_state->__pyx_n_s_dualsol_2); + Py_VISIT(traverse_module_state->__pyx_n_s_dummy_boundtypes); + Py_VISIT(traverse_module_state->__pyx_n_s_dummy_branchbounds); + Py_VISIT(traverse_module_state->__pyx_n_s_dummy_branchvars); + Py_VISIT(traverse_module_state->__pyx_n_s_dynamic); + Py_VISIT(traverse_module_state->__pyx_n_u_dynamic); + Py_VISIT(traverse_module_state->__pyx_n_s_e); + Py_VISIT(traverse_module_state->__pyx_n_s_eagerfreq); + Py_VISIT(traverse_module_state->__pyx_n_s_elem); + Py_VISIT(traverse_module_state->__pyx_n_s_enable); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_enableReoptimization); + Py_VISIT(traverse_module_state->__pyx_n_s_enablepricing); + Py_VISIT(traverse_module_state->__pyx_n_s_endDive); + Py_VISIT(traverse_module_state->__pyx_n_s_endProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_enfopriority); + Py_VISIT(traverse_module_state->__pyx_n_s_enforce); + Py_VISIT(traverse_module_state->__pyx_n_u_enforce); + Py_VISIT(traverse_module_state->__pyx_n_s_enfotype); + Py_VISIT(traverse_module_state->__pyx_n_s_ensure_iterable); + Py_VISIT(traverse_module_state->__pyx_n_s_enter); + Py_VISIT(traverse_module_state->__pyx_n_s_entries); + Py_VISIT(traverse_module_state->__pyx_n_s_entrieslist); + Py_VISIT(traverse_module_state->__pyx_n_s_entry); + Py_VISIT(traverse_module_state->__pyx_n_s_enumerate); + Py_VISIT(traverse_module_state->__pyx_n_s_epsilon); + Py_VISIT(traverse_module_state->__pyx_n_s_eq); + Py_VISIT(traverse_module_state->__pyx_n_s_eqchild); + Py_VISIT(traverse_module_state->__pyx_n_s_error); + Py_VISIT(traverse_module_state->__pyx_n_s_estimate); + Py_VISIT(traverse_module_state->__pyx_n_s_evaluate); + Py_VISIT(traverse_module_state->__pyx_n_s_event); + Py_VISIT(traverse_module_state->__pyx_kp_u_event_handler_not_found); + Py_VISIT(traverse_module_state->__pyx_n_s_eventcopy); + Py_VISIT(traverse_module_state->__pyx_n_s_eventdelete); + Py_VISIT(traverse_module_state->__pyx_n_s_eventexec); + Py_VISIT(traverse_module_state->__pyx_n_s_eventexit); + Py_VISIT(traverse_module_state->__pyx_n_s_eventexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_eventfree); + Py_VISIT(traverse_module_state->__pyx_n_s_eventhdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_eventhdlr_2); + Py_VISIT(traverse_module_state->__pyx_n_s_eventinit); + Py_VISIT(traverse_module_state->__pyx_n_s_eventinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_eventtype); + Py_VISIT(traverse_module_state->__pyx_n_s_exact); + Py_VISIT(traverse_module_state->__pyx_n_s_exit); + Py_VISIT(traverse_module_state->__pyx_n_s_exp); + Py_VISIT(traverse_module_state->__pyx_n_u_exp); + Py_VISIT(traverse_module_state->__pyx_kp_u_expected_inequality_that_has_eit); + Py_VISIT(traverse_module_state->__pyx_kp_u_expected_linear_inequality_expre); + Py_VISIT(traverse_module_state->__pyx_n_s_expo); + Py_VISIT(traverse_module_state->__pyx_n_s_exponent); + Py_VISIT(traverse_module_state->__pyx_kp_u_exponents_must_be_numbers); + Py_VISIT(traverse_module_state->__pyx_n_s_expr); + Py_VISIT(traverse_module_state->__pyx_n_s_expr_richcmp); + Py_VISIT(traverse_module_state->__pyx_n_s_expr_to_array); + Py_VISIT(traverse_module_state->__pyx_n_s_expr_to_nodes); + Py_VISIT(traverse_module_state->__pyx_n_s_ext); + Py_VISIT(traverse_module_state->__pyx_n_s_extend); + Py_VISIT(traverse_module_state->__pyx_n_s_extension); + Py_VISIT(traverse_module_state->__pyx_n_s_f); + Py_VISIT(traverse_module_state->__pyx_n_s_fabs); + Py_VISIT(traverse_module_state->__pyx_kp_u_failed); + Py_VISIT(traverse_module_state->__pyx_n_s_fdopen); + Py_VISIT(traverse_module_state->__pyx_n_s_feasFrac); + Py_VISIT(traverse_module_state->__pyx_n_s_feasibility); + Py_VISIT(traverse_module_state->__pyx_n_s_feasible); + Py_VISIT(traverse_module_state->__pyx_n_s_feastol); + Py_VISIT(traverse_module_state->__pyx_n_s_file); + Py_VISIT(traverse_module_state->__pyx_n_s_filename); + Py_VISIT(traverse_module_state->__pyx_n_s_fileno); + Py_VISIT(traverse_module_state->__pyx_n_s_firstcol); + Py_VISIT(traverse_module_state->__pyx_n_s_firstrow); + Py_VISIT(traverse_module_state->__pyx_n_s_fixVar); + Py_VISIT(traverse_module_state->__pyx_n_s_fixVarProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_fixed); + Py_VISIT(traverse_module_state->__pyx_n_s_fixedval); + Py_VISIT(traverse_module_state->__pyx_n_s_fixedvars); + Py_VISIT(traverse_module_state->__pyx_n_s_flushRowExtensions); + Py_VISIT(traverse_module_state->__pyx_n_s_fn); + Py_VISIT(traverse_module_state->__pyx_n_s_force); + Py_VISIT(traverse_module_state->__pyx_n_s_forcecut); + Py_VISIT(traverse_module_state->__pyx_n_s_forcedcuts); + Py_VISIT(traverse_module_state->__pyx_n_s_format); + Py_VISIT(traverse_module_state->__pyx_n_s_frac); + Py_VISIT(traverse_module_state->__pyx_n_s_free); + Py_VISIT(traverse_module_state->__pyx_n_s_freeBendersSubproblems); + Py_VISIT(traverse_module_state->__pyx_n_s_freeProb); + Py_VISIT(traverse_module_state->__pyx_n_s_freeReoptSolve); + Py_VISIT(traverse_module_state->__pyx_n_s_freeSol); + Py_VISIT(traverse_module_state->__pyx_n_s_freeTransform); + Py_VISIT(traverse_module_state->__pyx_n_s_freescip); + Py_VISIT(traverse_module_state->__pyx_n_s_freq); + Py_VISIT(traverse_module_state->__pyx_n_s_freqofs); + Py_VISIT(traverse_module_state->__pyx_n_s_from_ptr); + Py_VISIT(traverse_module_state->__pyx_n_u_gaplimit); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_genericnames); + Py_VISIT(traverse_module_state->__pyx_n_s_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_get); + Py_VISIT(traverse_module_state->__pyx_n_s_getActivity); + Py_VISIT(traverse_module_state->__pyx_n_s_getAddedConss); + Py_VISIT(traverse_module_state->__pyx_n_s_getBasisInds); + Py_VISIT(traverse_module_state->__pyx_n_s_getBasisStatus); + Py_VISIT(traverse_module_state->__pyx_n_s_getBendersAuxiliaryVar); + Py_VISIT(traverse_module_state->__pyx_n_s_getBendersSubproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_getBendersVar); + Py_VISIT(traverse_module_state->__pyx_n_s_getBestChild); + Py_VISIT(traverse_module_state->__pyx_n_s_getBestLeaf); + Py_VISIT(traverse_module_state->__pyx_n_s_getBestNode); + Py_VISIT(traverse_module_state->__pyx_n_s_getBestSibling); + Py_VISIT(traverse_module_state->__pyx_n_s_getBestSol); + Py_VISIT(traverse_module_state->__pyx_n_s_getBestboundNode); + Py_VISIT(traverse_module_state->__pyx_n_s_getBoundchgs); + Py_VISIT(traverse_module_state->__pyx_n_s_getBoundchgtype); + Py_VISIT(traverse_module_state->__pyx_n_s_getBounds); + Py_VISIT(traverse_module_state->__pyx_n_s_getBoundtype); + Py_VISIT(traverse_module_state->__pyx_n_s_getCol); + Py_VISIT(traverse_module_state->__pyx_n_s_getCols); + Py_VISIT(traverse_module_state->__pyx_n_s_getCondition); + Py_VISIT(traverse_module_state->__pyx_n_s_getConsNVars); + Py_VISIT(traverse_module_state->__pyx_n_s_getConsOriginConshdlrtype); + Py_VISIT(traverse_module_state->__pyx_n_s_getConsVars); + Py_VISIT(traverse_module_state->__pyx_n_s_getConshdlrName); + Py_VISIT(traverse_module_state->__pyx_n_s_getConss); + Py_VISIT(traverse_module_state->__pyx_n_s_getConstant); + Py_VISIT(traverse_module_state->__pyx_n_s_getCurrentNode); + Py_VISIT(traverse_module_state->__pyx_n_s_getCutEfficacy); + Py_VISIT(traverse_module_state->__pyx_n_s_getCutLPSolCutoffDistance); + Py_VISIT(traverse_module_state->__pyx_n_s_getDepth); + Py_VISIT(traverse_module_state->__pyx_n_s_getDomchg); + Py_VISIT(traverse_module_state->__pyx_n_s_getDual); + Py_VISIT(traverse_module_state->__pyx_n_s_getDualMultiplier); + Py_VISIT(traverse_module_state->__pyx_n_s_getDualRay); + Py_VISIT(traverse_module_state->__pyx_n_s_getDualSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_getDualbound); + Py_VISIT(traverse_module_state->__pyx_n_s_getDualboundRoot); + Py_VISIT(traverse_module_state->__pyx_n_s_getDualfarkasLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_getDualsol); + Py_VISIT(traverse_module_state->__pyx_n_s_getDualsolLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_getEstimate); + Py_VISIT(traverse_module_state->__pyx_n_s_getEventNames); + Py_VISIT(traverse_module_state->__pyx_n_s_getGap); + Py_VISIT(traverse_module_state->__pyx_n_s_getIndex); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPBInvARow); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPBInvRow); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPBasisInd); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPBranchCands); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPColsData); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPObjVal); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPPos); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPRowsData); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPSol); + Py_VISIT(traverse_module_state->__pyx_n_s_getLPSolstat); + Py_VISIT(traverse_module_state->__pyx_n_s_getLb); + Py_VISIT(traverse_module_state->__pyx_n_s_getLbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_getLbLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_getLbOriginal); + Py_VISIT(traverse_module_state->__pyx_n_s_getLhs); + Py_VISIT(traverse_module_state->__pyx_n_s_getLinearTerms); + Py_VISIT(traverse_module_state->__pyx_n_s_getLocalEstimate); + Py_VISIT(traverse_module_state->__pyx_n_s_getLowerbound); + Py_VISIT(traverse_module_state->__pyx_n_s_getNAddedConss); + Py_VISIT(traverse_module_state->__pyx_n_s_getNBestSolsFound); + Py_VISIT(traverse_module_state->__pyx_n_s_getNBinVars); + Py_VISIT(traverse_module_state->__pyx_n_s_getNChildren); + Py_VISIT(traverse_module_state->__pyx_n_s_getNConss); + Py_VISIT(traverse_module_state->__pyx_n_s_getNCountedSols); + Py_VISIT(traverse_module_state->__pyx_n_s_getNCuts); + Py_VISIT(traverse_module_state->__pyx_n_s_getNCutsApplied); + Py_VISIT(traverse_module_state->__pyx_n_s_getNDomchg); + Py_VISIT(traverse_module_state->__pyx_n_s_getNFeasibleLeaves); + Py_VISIT(traverse_module_state->__pyx_n_s_getNInfeasibleLeaves); + Py_VISIT(traverse_module_state->__pyx_n_s_getNIntVars); + Py_VISIT(traverse_module_state->__pyx_n_s_getNIterations); + Py_VISIT(traverse_module_state->__pyx_n_s_getNLPCols); + Py_VISIT(traverse_module_state->__pyx_n_s_getNLPIterations); + Py_VISIT(traverse_module_state->__pyx_n_s_getNLPNonz); + Py_VISIT(traverse_module_state->__pyx_n_s_getNLPRows); + Py_VISIT(traverse_module_state->__pyx_n_s_getNLPs); + Py_VISIT(traverse_module_state->__pyx_n_s_getNLeaves); + Py_VISIT(traverse_module_state->__pyx_n_s_getNLimSolsFound); + Py_VISIT(traverse_module_state->__pyx_n_s_getNNlRows); + Py_VISIT(traverse_module_state->__pyx_n_s_getNNodes); + Py_VISIT(traverse_module_state->__pyx_n_s_getNNonz); + Py_VISIT(traverse_module_state->__pyx_n_s_getNParentBranchings); + Py_VISIT(traverse_module_state->__pyx_n_s_getNReaders); + Py_VISIT(traverse_module_state->__pyx_n_s_getNSepaRounds); + Py_VISIT(traverse_module_state->__pyx_n_s_getNSiblings); + Py_VISIT(traverse_module_state->__pyx_n_s_getNSols); + Py_VISIT(traverse_module_state->__pyx_n_s_getNSolsFound); + Py_VISIT(traverse_module_state->__pyx_n_s_getNTotalNodes); + Py_VISIT(traverse_module_state->__pyx_n_s_getNVars); + Py_VISIT(traverse_module_state->__pyx_n_s_getName); + Py_VISIT(traverse_module_state->__pyx_n_s_getNewBound); + Py_VISIT(traverse_module_state->__pyx_n_s_getNlRowActivityBounds); + Py_VISIT(traverse_module_state->__pyx_n_s_getNlRowSolActivity); + Py_VISIT(traverse_module_state->__pyx_n_s_getNlRowSolFeasibility); + Py_VISIT(traverse_module_state->__pyx_n_s_getNlRows); + Py_VISIT(traverse_module_state->__pyx_n_s_getNode); + Py_VISIT(traverse_module_state->__pyx_n_s_getNorm); + Py_VISIT(traverse_module_state->__pyx_n_s_getNumber); + Py_VISIT(traverse_module_state->__pyx_n_s_getObj); + Py_VISIT(traverse_module_state->__pyx_n_s_getObjCoeff); + Py_VISIT(traverse_module_state->__pyx_n_s_getObjVal); + Py_VISIT(traverse_module_state->__pyx_n_s_getObjective); + Py_VISIT(traverse_module_state->__pyx_n_s_getObjectiveSense); + Py_VISIT(traverse_module_state->__pyx_n_s_getObjlimit); + Py_VISIT(traverse_module_state->__pyx_n_s_getObjoffset); + Py_VISIT(traverse_module_state->__pyx_n_s_getOldBound); + Py_VISIT(traverse_module_state->__pyx_n_s_getOp); + Py_VISIT(traverse_module_state->__pyx_n_s_getOpenNodes); + Py_VISIT(traverse_module_state->__pyx_n_s_getOrigintype); + Py_VISIT(traverse_module_state->__pyx_n_s_getParam); + Py_VISIT(traverse_module_state->__pyx_n_s_getParams); + Py_VISIT(traverse_module_state->__pyx_n_s_getParent); + Py_VISIT(traverse_module_state->__pyx_n_s_getParentBranchings); + Py_VISIT(traverse_module_state->__pyx_n_s_getPresolvingTime); + Py_VISIT(traverse_module_state->__pyx_n_s_getPrimal); + Py_VISIT(traverse_module_state->__pyx_n_s_getPrimalRay); + Py_VISIT(traverse_module_state->__pyx_n_s_getPrimalRayVal); + Py_VISIT(traverse_module_state->__pyx_n_s_getPrimalbound); + Py_VISIT(traverse_module_state->__pyx_n_s_getPrimsol); + Py_VISIT(traverse_module_state->__pyx_n_s_getProbName); + Py_VISIT(traverse_module_state->__pyx_n_s_getProbingDepth); + Py_VISIT(traverse_module_state->__pyx_n_s_getPseudoBranchCands); + Py_VISIT(traverse_module_state->__pyx_n_s_getReadingTime); + Py_VISIT(traverse_module_state->__pyx_n_s_getRedcost); + Py_VISIT(traverse_module_state->__pyx_n_s_getRhs); + Py_VISIT(traverse_module_state->__pyx_n_s_getRow); + Py_VISIT(traverse_module_state->__pyx_n_s_getRowActivity); + Py_VISIT(traverse_module_state->__pyx_n_s_getRowDualSol); + Py_VISIT(traverse_module_state->__pyx_n_s_getRowLPActivity); + Py_VISIT(traverse_module_state->__pyx_n_s_getRowLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_getRowNumIntCols); + Py_VISIT(traverse_module_state->__pyx_n_s_getRowObjParallelism); + Py_VISIT(traverse_module_state->__pyx_n_s_getRowParallelism); + Py_VISIT(traverse_module_state->__pyx_n_s_getSides); + Py_VISIT(traverse_module_state->__pyx_n_s_getSlack); + Py_VISIT(traverse_module_state->__pyx_n_s_getSlackVarIndicator); + Py_VISIT(traverse_module_state->__pyx_n_s_getSolObjVal); + Py_VISIT(traverse_module_state->__pyx_n_u_getSolObjVal); + Py_VISIT(traverse_module_state->__pyx_n_s_getSolTime); + Py_VISIT(traverse_module_state->__pyx_n_s_getSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_getSols); + Py_VISIT(traverse_module_state->__pyx_n_s_getSolvingTime); + Py_VISIT(traverse_module_state->__pyx_n_s_getStage); + Py_VISIT(traverse_module_state->__pyx_n_s_getStageName); + Py_VISIT(traverse_module_state->__pyx_n_s_getStageNames); + Py_VISIT(traverse_module_state->__pyx_n_s_getStatus); + Py_VISIT(traverse_module_state->__pyx_n_s_getTermsQuadratic); + Py_VISIT(traverse_module_state->__pyx_n_s_getTotalTime); + Py_VISIT(traverse_module_state->__pyx_n_s_getTransformedCons); + Py_VISIT(traverse_module_state->__pyx_n_s_getTransformedVar); + Py_VISIT(traverse_module_state->__pyx_n_s_getTreesizeEstimation); + Py_VISIT(traverse_module_state->__pyx_n_s_getType); + Py_VISIT(traverse_module_state->__pyx_n_s_getUb); + Py_VISIT(traverse_module_state->__pyx_n_s_getUbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_getUbLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_getUbOriginal); + Py_VISIT(traverse_module_state->__pyx_n_s_getVal); + Py_VISIT(traverse_module_state->__pyx_n_s_getVals); + Py_VISIT(traverse_module_state->__pyx_n_s_getValsLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_getVar); + Py_VISIT(traverse_module_state->__pyx_n_s_getVarDict); + Py_VISIT(traverse_module_state->__pyx_n_s_getVarLbDive); + Py_VISIT(traverse_module_state->__pyx_n_s_getVarRedcost); + Py_VISIT(traverse_module_state->__pyx_n_s_getVarUbDive); + Py_VISIT(traverse_module_state->__pyx_n_s_getVars); + Py_VISIT(traverse_module_state->__pyx_n_s_getitem); + Py_VISIT(traverse_module_state->__pyx_n_s_getitem___locals_genexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_getlocale); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_give_ownership); + Py_VISIT(traverse_module_state->__pyx_kp_u_given_coefficients_are_neither_E); + Py_VISIT(traverse_module_state->__pyx_kp_u_given_coefficients_are_not_Expr); + Py_VISIT(traverse_module_state->__pyx_kp_u_given_constraint_is_not_ExprCons); + Py_VISIT(traverse_module_state->__pyx_kp_u_given_constraint_is_not_linear_d); + Py_VISIT(traverse_module_state->__pyx_kp_u_given_constraint_is_not_quadrati); + Py_VISIT(traverse_module_state->__pyx_n_s_globalcopy); + Py_VISIT(traverse_module_state->__pyx_n_s_hasPrimalRay); + Py_VISIT(traverse_module_state->__pyx_n_s_hash); + Py_VISIT(traverse_module_state->__pyx_n_s_hashval); + Py_VISIT(traverse_module_state->__pyx_n_u_hashval); + Py_VISIT(traverse_module_state->__pyx_n_s_heur); + Py_VISIT(traverse_module_state->__pyx_n_s_heur_2); + Py_VISIT(traverse_module_state->__pyx_n_s_heurexec); + Py_VISIT(traverse_module_state->__pyx_n_s_heurexit); + Py_VISIT(traverse_module_state->__pyx_n_s_heurexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_heurfree); + Py_VISIT(traverse_module_state->__pyx_n_s_heurinit); + Py_VISIT(traverse_module_state->__pyx_n_s_heurinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_heurtiming); + Py_VISIT(traverse_module_state->__pyx_n_s_hideOutput); + Py_VISIT(traverse_module_state->__pyx_n_s_i); + Py_VISIT(traverse_module_state->__pyx_n_s_idx); + Py_VISIT(traverse_module_state->__pyx_n_s_idxs); + Py_VISIT(traverse_module_state->__pyx_n_s_implvars); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_inProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_inRepropagation); + Py_VISIT(traverse_module_state->__pyx_n_s_includeBenders); + Py_VISIT(traverse_module_state->__pyx_n_s_includeBendersDefaultCuts); + Py_VISIT(traverse_module_state->__pyx_n_s_includeBenderscut); + Py_VISIT(traverse_module_state->__pyx_n_s_includeBranchrule); + Py_VISIT(traverse_module_state->__pyx_n_s_includeConshdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_includeCutsel); + Py_VISIT(traverse_module_state->__pyx_n_s_includeDefaultPlugins); + Py_VISIT(traverse_module_state->__pyx_n_s_includeEventhdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_includeHeur); + Py_VISIT(traverse_module_state->__pyx_n_s_includeNodesel); + Py_VISIT(traverse_module_state->__pyx_n_s_includePresol); + Py_VISIT(traverse_module_state->__pyx_n_s_includePricer); + Py_VISIT(traverse_module_state->__pyx_n_s_includeProp); + Py_VISIT(traverse_module_state->__pyx_n_s_includeReader); + Py_VISIT(traverse_module_state->__pyx_n_s_includeRelax); + Py_VISIT(traverse_module_state->__pyx_n_s_includeSepa); + Py_VISIT(traverse_module_state->__pyx_n_s_indices); + Py_VISIT(traverse_module_state->__pyx_n_s_inds); + Py_VISIT(traverse_module_state->__pyx_n_s_indvar); + Py_VISIT(traverse_module_state->__pyx_n_s_indvars); + Py_VISIT(traverse_module_state->__pyx_n_u_inf); + Py_VISIT(traverse_module_state->__pyx_n_s_infeasible); + Py_VISIT(traverse_module_state->__pyx_n_u_infeasible); + Py_VISIT(traverse_module_state->__pyx_n_s_infeasible_2); + Py_VISIT(traverse_module_state->__pyx_n_s_inferinfo); + Py_VISIT(traverse_module_state->__pyx_n_s_infinity); + Py_VISIT(traverse_module_state->__pyx_n_u_inforunbd); + Py_VISIT(traverse_module_state->__pyx_n_s_init); + Py_VISIT(traverse_module_state->__pyx_n_s_initBendersDefault); + Py_VISIT(traverse_module_state->__pyx_n_s_init_subclass); + Py_VISIT(traverse_module_state->__pyx_n_s_initial); + Py_VISIT(traverse_module_state->__pyx_n_u_initial); + Py_VISIT(traverse_module_state->__pyx_n_s_initializing); + Py_VISIT(traverse_module_state->__pyx_n_s_interruptSolve); + Py_VISIT(traverse_module_state->__pyx_n_s_intvars); + Py_VISIT(traverse_module_state->__pyx_n_s_isActive); + Py_VISIT(traverse_module_state->__pyx_n_s_isChecked); + Py_VISIT(traverse_module_state->__pyx_n_s_isCutEfficacious); + Py_VISIT(traverse_module_state->__pyx_n_s_isDualFeasible); + Py_VISIT(traverse_module_state->__pyx_n_s_isDynamic); + Py_VISIT(traverse_module_state->__pyx_n_s_isEQ); + Py_VISIT(traverse_module_state->__pyx_n_s_isEnforced); + Py_VISIT(traverse_module_state->__pyx_n_s_isFeasEQ); + Py_VISIT(traverse_module_state->__pyx_n_s_isFeasIntegral); + Py_VISIT(traverse_module_state->__pyx_n_s_isFeasNegative); + Py_VISIT(traverse_module_state->__pyx_n_s_isFeasZero); + Py_VISIT(traverse_module_state->__pyx_n_s_isGE); + Py_VISIT(traverse_module_state->__pyx_n_s_isGT); + Py_VISIT(traverse_module_state->__pyx_n_s_isInGlobalCutpool); + Py_VISIT(traverse_module_state->__pyx_n_s_isInLP); + Py_VISIT(traverse_module_state->__pyx_n_s_isInfinity); + Py_VISIT(traverse_module_state->__pyx_n_s_isInitial); + Py_VISIT(traverse_module_state->__pyx_n_s_isIntegral); + Py_VISIT(traverse_module_state->__pyx_n_s_isLE); + Py_VISIT(traverse_module_state->__pyx_n_s_isLPSolBasic); + Py_VISIT(traverse_module_state->__pyx_n_s_isLT); + Py_VISIT(traverse_module_state->__pyx_n_s_isLinear); + Py_VISIT(traverse_module_state->__pyx_n_s_isLocal); + Py_VISIT(traverse_module_state->__pyx_n_s_isModifiable); + Py_VISIT(traverse_module_state->__pyx_n_s_isNLPConstructed); + Py_VISIT(traverse_module_state->__pyx_n_s_isNonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_isObjChangedProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_isOriginal); + Py_VISIT(traverse_module_state->__pyx_n_s_isPrimalFeasible); + Py_VISIT(traverse_module_state->__pyx_n_s_isPropagated); + Py_VISIT(traverse_module_state->__pyx_n_s_isPropagatedAgain); + Py_VISIT(traverse_module_state->__pyx_n_s_isRedundant); + Py_VISIT(traverse_module_state->__pyx_n_s_isRemovable); + Py_VISIT(traverse_module_state->__pyx_n_s_isSeparated); + Py_VISIT(traverse_module_state->__pyx_n_s_isStickingAtNode); + Py_VISIT(traverse_module_state->__pyx_n_s_isZero); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_n_s_is_integer); + Py_VISIT(traverse_module_state->__pyx_n_s_is_memory_freed); + Py_VISIT(traverse_module_state->__pyx_n_s_is_number); + Py_VISIT(traverse_module_state->__pyx_n_s_isconvex); + Py_VISIT(traverse_module_state->__pyx_n_s_isdict); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_islpcut); + Py_VISIT(traverse_module_state->__pyx_n_s_isquadratic); + Py_VISIT(traverse_module_state->__pyx_n_s_items); + Py_VISIT(traverse_module_state->__pyx_n_s_iters); + Py_VISIT(traverse_module_state->__pyx_n_s_itertools); + Py_VISIT(traverse_module_state->__pyx_n_s_itlim); + Py_VISIT(traverse_module_state->__pyx_n_s_j); + Py_VISIT(traverse_module_state->__pyx_n_s_key); + Py_VISIT(traverse_module_state->__pyx_n_s_keys); + Py_VISIT(traverse_module_state->__pyx_n_s_kwargs); + Py_VISIT(traverse_module_state->__pyx_n_s_lambda); + Py_VISIT(traverse_module_state->__pyx_n_s_lastcol); + Py_VISIT(traverse_module_state->__pyx_n_s_lastrow); + Py_VISIT(traverse_module_state->__pyx_n_s_lb); + Py_VISIT(traverse_module_state->__pyx_n_s_lbs); + Py_VISIT(traverse_module_state->__pyx_n_s_leaves); + Py_VISIT(traverse_module_state->__pyx_n_s_leaves_2); + Py_VISIT(traverse_module_state->__pyx_n_s_len); + Py_VISIT(traverse_module_state->__pyx_n_s_length); + Py_VISIT(traverse_module_state->__pyx_n_s_lhs); + Py_VISIT(traverse_module_state->__pyx_n_u_lhs); + Py_VISIT(traverse_module_state->__pyx_n_s_lhs_2); + Py_VISIT(traverse_module_state->__pyx_n_s_lhss); + Py_VISIT(traverse_module_state->__pyx_n_s_lhsslack); + Py_VISIT(traverse_module_state->__pyx_n_s_lincoef); + Py_VISIT(traverse_module_state->__pyx_n_s_lincoefs); + Py_VISIT(traverse_module_state->__pyx_n_s_lincoefs_2); + Py_VISIT(traverse_module_state->__pyx_n_s_lincons); + Py_VISIT(traverse_module_state->__pyx_n_u_linear); + Py_VISIT(traverse_module_state->__pyx_n_s_linexprs); + Py_VISIT(traverse_module_state->__pyx_kp_u_linked_SCIP_is_not_compatible_to); + Py_VISIT(traverse_module_state->__pyx_kp_u_linked_SCIP_is_not_recommended_f); + Py_VISIT(traverse_module_state->__pyx_n_s_linterms); + Py_VISIT(traverse_module_state->__pyx_n_s_linvars); + Py_VISIT(traverse_module_state->__pyx_n_s_local); + Py_VISIT(traverse_module_state->__pyx_n_u_local); + Py_VISIT(traverse_module_state->__pyx_n_s_locale); + Py_VISIT(traverse_module_state->__pyx_n_s_locktype); + Py_VISIT(traverse_module_state->__pyx_n_s_log); + Py_VISIT(traverse_module_state->__pyx_n_u_log); + Py_VISIT(traverse_module_state->__pyx_n_u_lower); + Py_VISIT(traverse_module_state->__pyx_n_u_lowerbound); + Py_VISIT(traverse_module_state->__pyx_n_s_lowerbounds); + Py_VISIT(traverse_module_state->__pyx_n_s_lpcands); + Py_VISIT(traverse_module_state->__pyx_n_s_lpcandsfrac); + Py_VISIT(traverse_module_state->__pyx_n_s_lpcandssol); + Py_VISIT(traverse_module_state->__pyx_n_s_lperror); + Py_VISIT(traverse_module_state->__pyx_n_s_lpi); + Py_VISIT(traverse_module_state->__pyx_n_s_lpiGetIterations); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_map); + Py_VISIT(traverse_module_state->__pyx_n_s_mappedvar); + Py_VISIT(traverse_module_state->__pyx_n_u_mappedvar); + Py_VISIT(traverse_module_state->__pyx_n_s_mappedvar_2); + Py_VISIT(traverse_module_state->__pyx_n_s_max); + Py_VISIT(traverse_module_state->__pyx_n_s_maxactivity); + Py_VISIT(traverse_module_state->__pyx_n_s_maxbounddist); + Py_VISIT(traverse_module_state->__pyx_n_s_maxdepth); + Py_VISIT(traverse_module_state->__pyx_n_u_maximize); + Py_VISIT(traverse_module_state->__pyx_n_s_maxnconss); + Py_VISIT(traverse_module_state->__pyx_n_s_maxnselectedcuts); + Py_VISIT(traverse_module_state->__pyx_n_s_maxprerounds); + Py_VISIT(traverse_module_state->__pyx_n_s_maxproprounds); + Py_VISIT(traverse_module_state->__pyx_n_s_maxrounds); + Py_VISIT(traverse_module_state->__pyx_n_u_memlimit); + Py_VISIT(traverse_module_state->__pyx_n_s_memsavepriority); + Py_VISIT(traverse_module_state->__pyx_n_s_mergecandidates); + Py_VISIT(traverse_module_state->__pyx_n_u_merged); + Py_VISIT(traverse_module_state->__pyx_n_s_metaclass); + Py_VISIT(traverse_module_state->__pyx_n_s_method); + Py_VISIT(traverse_module_state->__pyx_kp_u_method_can_only_be_called_in_sta); + Py_VISIT(traverse_module_state->__pyx_kp_u_method_cannot_be_called_before_p); + Py_VISIT(traverse_module_state->__pyx_kp_u_method_cannot_be_called_for_cons); + Py_VISIT(traverse_module_state->__pyx_n_s_minactivity); + Py_VISIT(traverse_module_state->__pyx_n_u_minimize); + Py_VISIT(traverse_module_state->__pyx_n_s_minus); + Py_VISIT(traverse_module_state->__pyx_n_s_model); + Py_VISIT(traverse_module_state->__pyx_n_u_model); + Py_VISIT(traverse_module_state->__pyx_kp_u_model_cip); + Py_VISIT(traverse_module_state->__pyx_kp_u_model_getDualMultiplier_cons_is); + Py_VISIT(traverse_module_state->__pyx_n_s_modifiable); + Py_VISIT(traverse_module_state->__pyx_n_u_modifiable); + Py_VISIT(traverse_module_state->__pyx_n_s_module); + Py_VISIT(traverse_module_state->__pyx_n_s_monomials); + Py_VISIT(traverse_module_state->__pyx_n_s_mul); + Py_VISIT(traverse_module_state->__pyx_n_s_mul_2); + Py_VISIT(traverse_module_state->__pyx_n_s_myMessageHandler); + Py_VISIT(traverse_module_state->__pyx_n_s_n); + Py_VISIT(traverse_module_state->__pyx_n_s_n_conss); + Py_VISIT(traverse_module_state->__pyx_n_u_naddconss); + Py_VISIT(traverse_module_state->__pyx_n_u_naddholes); + Py_VISIT(traverse_module_state->__pyx_n_u_naggrvars); + Py_VISIT(traverse_module_state->__pyx_n_s_nam); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_u_name); + Py_VISIT(traverse_module_state->__pyx_n_s_name_2); + Py_VISIT(traverse_module_state->__pyx_n_s_nbenders); + Py_VISIT(traverse_module_state->__pyx_n_s_nbilinterms); + Py_VISIT(traverse_module_state->__pyx_n_s_nboundchgs); + Py_VISIT(traverse_module_state->__pyx_n_s_nbranchings); + Py_VISIT(traverse_module_state->__pyx_n_s_nbranchvars); + Py_VISIT(traverse_module_state->__pyx_n_s_ncands); + Py_VISIT(traverse_module_state->__pyx_n_u_nchgbds); + Py_VISIT(traverse_module_state->__pyx_n_u_nchgcoefs); + Py_VISIT(traverse_module_state->__pyx_n_u_nchgsides); + Py_VISIT(traverse_module_state->__pyx_n_u_nchgvartypes); + Py_VISIT(traverse_module_state->__pyx_n_s_nchildren); + Py_VISIT(traverse_module_state->__pyx_n_s_nchildren_2); + Py_VISIT(traverse_module_state->__pyx_n_s_ncols); + Py_VISIT(traverse_module_state->__pyx_n_s_nconsprop); + Py_VISIT(traverse_module_state->__pyx_n_s_nconss); + Py_VISIT(traverse_module_state->__pyx_n_s_nconss_2); + Py_VISIT(traverse_module_state->__pyx_n_u_ndelconss); + Py_VISIT(traverse_module_state->__pyx_n_s_ndomredsfound); + Py_VISIT(traverse_module_state->__pyx_n_s_needscons); + Py_VISIT(traverse_module_state->__pyx_n_s_negate); + Py_VISIT(traverse_module_state->__pyx_n_s_new); + Py_VISIT(traverse_module_state->__pyx_n_s_newCheck); + Py_VISIT(traverse_module_state->__pyx_n_s_newEnf); + Py_VISIT(traverse_module_state->__pyx_n_s_newInit); + Py_VISIT(traverse_module_state->__pyx_n_s_newProbingNode); + Py_VISIT(traverse_module_state->__pyx_n_s_newRem); + Py_VISIT(traverse_module_state->__pyx_n_s_newbound); + Py_VISIT(traverse_module_state->__pyx_n_s_newlhs); + Py_VISIT(traverse_module_state->__pyx_n_s_newobj); + Py_VISIT(traverse_module_state->__pyx_n_s_newrhs); + Py_VISIT(traverse_module_state->__pyx_n_s_newval); + Py_VISIT(traverse_module_state->__pyx_n_u_nfixedvars); + Py_VISIT(traverse_module_state->__pyx_n_s_nfracimplvars); + Py_VISIT(traverse_module_state->__pyx_n_s_niters); + Py_VISIT(traverse_module_state->__pyx_n_s_nleaves); + Py_VISIT(traverse_module_state->__pyx_n_s_nlinvars); + Py_VISIT(traverse_module_state->__pyx_n_s_nlinvars_2); + Py_VISIT(traverse_module_state->__pyx_n_s_nlocksdown); + Py_VISIT(traverse_module_state->__pyx_n_s_nlocksneg); + Py_VISIT(traverse_module_state->__pyx_n_s_nlockspos); + Py_VISIT(traverse_module_state->__pyx_n_s_nlocksup); + Py_VISIT(traverse_module_state->__pyx_n_s_nlpcands); + Py_VISIT(traverse_module_state->__pyx_n_s_nlrow); + Py_VISIT(traverse_module_state->__pyx_n_s_nlrows); + Py_VISIT(traverse_module_state->__pyx_n_s_nmarkedconss); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewaddconss); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewaddconss); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewaddholes); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewaggrvars); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewaggrvars); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewchgbds); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewchgbds); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewchgcoefs); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewchgcoefs); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewchgsides); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewchgsides); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewchgvartypes); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewchgvartypes); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewdelconss); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewdelconss); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewfixedvars); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewfixedvars); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewholes); + Py_VISIT(traverse_module_state->__pyx_n_s_nnewupgdconss); + Py_VISIT(traverse_module_state->__pyx_n_u_nnewupgdconss); + Py_VISIT(traverse_module_state->__pyx_n_s_nnonz); + Py_VISIT(traverse_module_state->__pyx_kp_u_no_reduced_cost_available_for_va); + Py_VISIT(traverse_module_state->__pyx_n_s_node); + Py_VISIT(traverse_module_state->__pyx_n_s_node1); + Py_VISIT(traverse_module_state->__pyx_n_s_node2); + Py_VISIT(traverse_module_state->__pyx_n_s_nodecomp); + Py_VISIT(traverse_module_state->__pyx_n_s_nodeexit); + Py_VISIT(traverse_module_state->__pyx_n_s_nodeexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_nodefree); + Py_VISIT(traverse_module_state->__pyx_n_s_nodeinfeasible); + Py_VISIT(traverse_module_state->__pyx_n_s_nodeinit); + Py_VISIT(traverse_module_state->__pyx_n_s_nodeinitsol); + Py_VISIT(traverse_module_state->__pyx_n_u_nodelimit); + Py_VISIT(traverse_module_state->__pyx_n_s_nodes); + Py_VISIT(traverse_module_state->__pyx_n_s_nodesel); + Py_VISIT(traverse_module_state->__pyx_n_s_nodeselect); + Py_VISIT(traverse_module_state->__pyx_n_s_nodeselprio); + Py_VISIT(traverse_module_state->__pyx_n_u_nonlinear); + Py_VISIT(traverse_module_state->__pyx_n_s_normalize); + Py_VISIT(traverse_module_state->__pyx_n_s_npriolpcands); + Py_VISIT(traverse_module_state->__pyx_n_s_npriomergecands); + Py_VISIT(traverse_module_state->__pyx_n_s_npriopseudocands); + Py_VISIT(traverse_module_state->__pyx_n_s_nprop); + Py_VISIT(traverse_module_state->__pyx_n_s_npseudocands); + Py_VISIT(traverse_module_state->__pyx_n_s_nquadterms); + Py_VISIT(traverse_module_state->__pyx_n_s_nrounds); + Py_VISIT(traverse_module_state->__pyx_n_s_nrows); + Py_VISIT(traverse_module_state->__pyx_n_u_nselectedcuts); + Py_VISIT(traverse_module_state->__pyx_n_s_nsiblings); + Py_VISIT(traverse_module_state->__pyx_n_s_nsols); + Py_VISIT(traverse_module_state->__pyx_n_s_nsubproblems); + Py_VISIT(traverse_module_state->__pyx_n_s_number); + Py_VISIT(traverse_module_state->__pyx_n_u_nupgdconss); + Py_VISIT(traverse_module_state->__pyx_n_s_nusefulconss); + Py_VISIT(traverse_module_state->__pyx_n_s_nvars); + Py_VISIT(traverse_module_state->__pyx_n_u_nvars); + Py_VISIT(traverse_module_state->__pyx_n_s_nvars_2); + Py_VISIT(traverse_module_state->__pyx_n_s_obj); + Py_VISIT(traverse_module_state->__pyx_n_s_objective); + Py_VISIT(traverse_module_state->__pyx_n_u_objective); + Py_VISIT(traverse_module_state->__pyx_n_s_objinfeasible); + Py_VISIT(traverse_module_state->__pyx_n_s_objlimit); + Py_VISIT(traverse_module_state->__pyx_n_s_objoffset); + Py_VISIT(traverse_module_state->__pyx_n_s_objs); + Py_VISIT(traverse_module_state->__pyx_n_s_objscale); + Py_VISIT(traverse_module_state->__pyx_n_s_objsense); + Py_VISIT(traverse_module_state->__pyx_n_s_objval); + Py_VISIT(traverse_module_state->__pyx_n_s_offset); + Py_VISIT(traverse_module_state->__pyx_n_s_onlychanged); + Py_VISIT(traverse_module_state->__pyx_n_s_onlyconvex); + Py_VISIT(traverse_module_state->__pyx_n_s_onlydelayed); + Py_VISIT(traverse_module_state->__pyx_n_s_onlyroot); + Py_VISIT(traverse_module_state->__pyx_n_s_op); + Py_VISIT(traverse_module_state->__pyx_n_s_op_2); + Py_VISIT(traverse_module_state->__pyx_n_s_open); + Py_VISIT(traverse_module_state->__pyx_n_s_opidx); + Py_VISIT(traverse_module_state->__pyx_n_s_optimal); + Py_VISIT(traverse_module_state->__pyx_n_u_optimal); + Py_VISIT(traverse_module_state->__pyx_n_s_optimize); + Py_VISIT(traverse_module_state->__pyx_n_s_origcopy); + Py_VISIT(traverse_module_state->__pyx_n_s_original); + Py_VISIT(traverse_module_state->__pyx_kp_u_origprob_sol); + Py_VISIT(traverse_module_state->__pyx_kp_u_origprob_stats); + Py_VISIT(traverse_module_state->__pyx_n_s_orthofunc); + Py_VISIT(traverse_module_state->__pyx_n_s_os); + Py_VISIT(traverse_module_state->__pyx_n_s_os_path); + Py_VISIT(traverse_module_state->__pyx_n_s_other); + Py_VISIT(traverse_module_state->__pyx_n_s_paraemphasis); + Py_VISIT(traverse_module_state->__pyx_n_s_param); + Py_VISIT(traverse_module_state->__pyx_kp_u_param_set); + Py_VISIT(traverse_module_state->__pyx_n_s_params); + Py_VISIT(traverse_module_state->__pyx_n_s_paramtype); + Py_VISIT(traverse_module_state->__pyx_n_s_partial); + Py_VISIT(traverse_module_state->__pyx_n_s_partialsolution); + Py_VISIT(traverse_module_state->__pyx_n_s_path); + Py_VISIT(traverse_module_state->__pyx_n_s_pickle); + Py_VISIT(traverse_module_state->__pyx_n_s_plus); + Py_VISIT(traverse_module_state->__pyx_n_s_pos); + Py_VISIT(traverse_module_state->__pyx_n_s_power); + Py_VISIT(traverse_module_state->__pyx_n_s_prepare); + Py_VISIT(traverse_module_state->__pyx_n_s_presol); + Py_VISIT(traverse_module_state->__pyx_n_s_presolexec); + Py_VISIT(traverse_module_state->__pyx_n_s_presolexit); + Py_VISIT(traverse_module_state->__pyx_n_s_presolexitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_presolfree); + Py_VISIT(traverse_module_state->__pyx_n_s_presolinit); + Py_VISIT(traverse_module_state->__pyx_n_s_presolinitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_presolmaxrounds); + Py_VISIT(traverse_module_state->__pyx_n_s_presolpriority); + Py_VISIT(traverse_module_state->__pyx_n_s_presoltiming); + Py_VISIT(traverse_module_state->__pyx_n_s_presolve); + Py_VISIT(traverse_module_state->__pyx_n_s_pretendroot); + Py_VISIT(traverse_module_state->__pyx_n_s_pricedVar); + Py_VISIT(traverse_module_state->__pyx_n_s_pricedVarScore); + Py_VISIT(traverse_module_state->__pyx_n_s_pricer); + Py_VISIT(traverse_module_state->__pyx_n_s_pricerexit); + Py_VISIT(traverse_module_state->__pyx_n_s_pricerexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_pricerfarkas); + Py_VISIT(traverse_module_state->__pyx_kp_u_pricerfarkas_is_a_fundamental_ca); + Py_VISIT(traverse_module_state->__pyx_n_s_pricerfree); + Py_VISIT(traverse_module_state->__pyx_n_s_pricerinit); + Py_VISIT(traverse_module_state->__pyx_n_s_pricerinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_pricerredcost); + Py_VISIT(traverse_module_state->__pyx_kp_u_pricerredcost_is_a_fundamental_c); + Py_VISIT(traverse_module_state->__pyx_n_u_primallimit); + Py_VISIT(traverse_module_state->__pyx_n_s_primalsol); + Py_VISIT(traverse_module_state->__pyx_n_s_print); + Py_VISIT(traverse_module_state->__pyx_n_s_printBestSol); + Py_VISIT(traverse_module_state->__pyx_n_s_printCons); + Py_VISIT(traverse_module_state->__pyx_n_s_printExternalCodeVersions); + Py_VISIT(traverse_module_state->__pyx_n_s_printNlRow); + Py_VISIT(traverse_module_state->__pyx_n_s_printRow); + Py_VISIT(traverse_module_state->__pyx_n_s_printSol); + Py_VISIT(traverse_module_state->__pyx_n_s_printStatistics); + Py_VISIT(traverse_module_state->__pyx_n_s_printVersion); + Py_VISIT(traverse_module_state->__pyx_n_s_print_memory_in_use); + Py_VISIT(traverse_module_state->__pyx_n_s_printreason); + Py_VISIT(traverse_module_state->__pyx_n_s_priority); + Py_VISIT(traverse_module_state->__pyx_n_s_probingdepth); + Py_VISIT(traverse_module_state->__pyx_n_s_problemName); + Py_VISIT(traverse_module_state->__pyx_n_s_probnumber); + Py_VISIT(traverse_module_state->__pyx_n_s_prod); + Py_VISIT(traverse_module_state->__pyx_n_u_prod); + Py_VISIT(traverse_module_state->__pyx_n_s_prodexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_prop); + Py_VISIT(traverse_module_state->__pyx_n_s_propagate); + Py_VISIT(traverse_module_state->__pyx_n_u_propagate); + Py_VISIT(traverse_module_state->__pyx_n_s_propagateProbing); + Py_VISIT(traverse_module_state->__pyx_kp_u_propagating_maxrounds); + Py_VISIT(traverse_module_state->__pyx_kp_u_propagating_maxroundsroot); + Py_VISIT(traverse_module_state->__pyx_n_s_propexec); + Py_VISIT(traverse_module_state->__pyx_n_s_propexit); + Py_VISIT(traverse_module_state->__pyx_n_s_propexitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_propexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_propfree); + Py_VISIT(traverse_module_state->__pyx_n_s_propfreq); + Py_VISIT(traverse_module_state->__pyx_n_s_propinit); + Py_VISIT(traverse_module_state->__pyx_n_s_propinitpre); + Py_VISIT(traverse_module_state->__pyx_n_s_propinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_proppresol); + Py_VISIT(traverse_module_state->__pyx_n_s_propresprop); + Py_VISIT(traverse_module_state->__pyx_n_s_proptiming); + Py_VISIT(traverse_module_state->__pyx_n_s_proxy); + Py_VISIT(traverse_module_state->__pyx_n_s_pseudocands); + Py_VISIT(traverse_module_state->__pyx_n_s_ptr); + Py_VISIT(traverse_module_state->__pyx_n_s_ptrtuple); + Py_VISIT(traverse_module_state->__pyx_n_u_ptrtuple); + Py_VISIT(traverse_module_state->__pyx_n_s_pyCons); + Py_VISIT(traverse_module_state->__pyx_n_s_pyVar); + Py_VISIT(traverse_module_state->__pyx_n_s_py_boundtypes); + Py_VISIT(traverse_module_state->__pyx_n_s_py_branchbounds); + Py_VISIT(traverse_module_state->__pyx_n_s_py_variables); + Py_VISIT(traverse_module_state->__pyx_n_s_pycons); + Py_VISIT(traverse_module_state->__pyx_n_s_pycons_initial); + Py_VISIT(traverse_module_state->__pyx_n_s_pyscipopt_scip); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_benderscreatesub); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_benderscutexec_t); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_bendersgetvar_th); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_conscheck_this_m); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_consenfolp_this); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_consenfops_this); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_consenforelax_th); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_conslock_this_me); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_eventexec_this_m); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_heurexec_this_me); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_presolexec_this); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_propexec_this_me); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_propresprop_this); + Py_VISIT(traverse_module_state->__pyx_kp_u_python_error_in_relaxexec_this_m); + Py_VISIT(traverse_module_state->__pyx_n_s_pyvar); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Benderscut); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Branchrule); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Conshdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Constant); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Cutsel); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Eventhdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Expr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_ExprCons); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_GenExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Heur); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Nodesel); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_RESULT); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_STAGE); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PY_SCIP_STATUS); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_PowExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Presol); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Pricer); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_ProdExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Prop); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Reader); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Relax); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_Sepa); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_SumExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_UnaryExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle_VarExpr); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); + Py_VISIT(traverse_module_state->__pyx_n_s_quadcons); + Py_VISIT(traverse_module_state->__pyx_n_u_quadratic); + Py_VISIT(traverse_module_state->__pyx_n_s_quadterms); + Py_VISIT(traverse_module_state->__pyx_n_s_quality); + Py_VISIT(traverse_module_state->__pyx_n_s_qualname); + Py_VISIT(traverse_module_state->__pyx_n_s_quickprod); + Py_VISIT(traverse_module_state->__pyx_n_s_quicksum); + Py_VISIT(traverse_module_state->__pyx_n_s_quiet); + Py_VISIT(traverse_module_state->__pyx_n_s_raise_error); + Py_VISIT(traverse_module_state->__pyx_n_s_range); + Py_VISIT(traverse_module_state->__pyx_n_s_ray); + Py_VISIT(traverse_module_state->__pyx_n_s_rc); + Py_VISIT(traverse_module_state->__pyx_n_s_readLP); + Py_VISIT(traverse_module_state->__pyx_n_s_readParams); + Py_VISIT(traverse_module_state->__pyx_n_s_readProblem); + Py_VISIT(traverse_module_state->__pyx_n_s_readSol); + Py_VISIT(traverse_module_state->__pyx_n_s_readSolFile); + Py_VISIT(traverse_module_state->__pyx_n_s_reader); + Py_VISIT(traverse_module_state->__pyx_n_s_readerfree); + Py_VISIT(traverse_module_state->__pyx_n_s_readerread); + Py_VISIT(traverse_module_state->__pyx_n_s_readerwrite); + Py_VISIT(traverse_module_state->__pyx_n_s_redcost); + Py_VISIT(traverse_module_state->__pyx_n_s_redirectOutput); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_relax); + Py_VISIT(traverse_module_state->__pyx_n_s_relaxcons); + Py_VISIT(traverse_module_state->__pyx_n_s_relaxedbd); + Py_VISIT(traverse_module_state->__pyx_n_s_relaxexec); + Py_VISIT(traverse_module_state->__pyx_kp_u_relaxexec_must_return_a_dictiona); + Py_VISIT(traverse_module_state->__pyx_n_s_relaxexit); + Py_VISIT(traverse_module_state->__pyx_n_s_relaxexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_relaxfree); + Py_VISIT(traverse_module_state->__pyx_n_s_relaxinit); + Py_VISIT(traverse_module_state->__pyx_n_s_relaxinitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_releaseRow); + Py_VISIT(traverse_module_state->__pyx_n_s_removable); + Py_VISIT(traverse_module_state->__pyx_n_u_removable); + Py_VISIT(traverse_module_state->__pyx_n_s_repeat); + Py_VISIT(traverse_module_state->__pyx_n_s_repr); + Py_VISIT(traverse_module_state->__pyx_n_s_repr___locals_lambda); + Py_VISIT(traverse_module_state->__pyx_n_s_repropagateNode); + Py_VISIT(traverse_module_state->__pyx_n_s_resVar); + Py_VISIT(traverse_module_state->__pyx_n_s_resetParam); + Py_VISIT(traverse_module_state->__pyx_n_s_resetParams); + Py_VISIT(traverse_module_state->__pyx_n_s_restart); + Py_VISIT(traverse_module_state->__pyx_n_s_restartSolve); + Py_VISIT(traverse_module_state->__pyx_n_u_restartlimit); + Py_VISIT(traverse_module_state->__pyx_n_s_result); + Py_VISIT(traverse_module_state->__pyx_n_u_result); + Py_VISIT(traverse_module_state->__pyx_n_s_result_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_resvar); + Py_VISIT(traverse_module_state->__pyx_n_s_retcode); + Py_VISIT(traverse_module_state->__pyx_n_s_rhs); + Py_VISIT(traverse_module_state->__pyx_n_u_rhs); + Py_VISIT(traverse_module_state->__pyx_n_s_rhs_2); + Py_VISIT(traverse_module_state->__pyx_n_s_rhss); + Py_VISIT(traverse_module_state->__pyx_n_s_rhsslack); + Py_VISIT(traverse_module_state->__pyx_n_s_rhsvar); + Py_VISIT(traverse_module_state->__pyx_n_s_root); + Py_VISIT(traverse_module_state->__pyx_n_s_row); + Py_VISIT(traverse_module_state->__pyx_n_u_row); + Py_VISIT(traverse_module_state->__pyx_n_s_row1); + Py_VISIT(traverse_module_state->__pyx_n_s_row2); + Py_VISIT(traverse_module_state->__pyx_n_s_rows); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_benders); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_benderscut); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_col); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_con); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_cons); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_conshdlr); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_expr); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_pricer); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_sepa); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_sol); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_subprob); + Py_VISIT(traverse_module_state->__pyx_n_s_scip_var); + Py_VISIT(traverse_module_state->__pyx_n_s_scipexprs); + Py_VISIT(traverse_module_state->__pyx_n_s_scipvar1); + Py_VISIT(traverse_module_state->__pyx_n_s_scipvar2); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_kp_s_self__benders_cannot_be_converte); + Py_VISIT(traverse_module_state->__pyx_kp_s_self__scip_self__valid_cannot_be); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_event_cannot_be_converted_t); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_lpi_cannot_be_converted_to); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_boundchg_cannot_be_con); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_col_cannot_be_converte); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_cons_cannot_be_convert); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_domchg_cannot_be_conve); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_nlrow_cannot_be_conver); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_node_cannot_be_convert); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_row_cannot_be_converte); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_self_sol_cannot_be_con); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_scip_var_cannot_be_converte); + Py_VISIT(traverse_module_state->__pyx_n_u_selnode); + Py_VISIT(traverse_module_state->__pyx_n_s_send); + Py_VISIT(traverse_module_state->__pyx_n_s_sense); + Py_VISIT(traverse_module_state->__pyx_n_s_sepa); + Py_VISIT(traverse_module_state->__pyx_n_s_sepaexeclp); + Py_VISIT(traverse_module_state->__pyx_n_s_sepaexecsol); + Py_VISIT(traverse_module_state->__pyx_n_s_sepaexit); + Py_VISIT(traverse_module_state->__pyx_n_s_sepaexitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_sepafree); + Py_VISIT(traverse_module_state->__pyx_n_s_sepafreq); + Py_VISIT(traverse_module_state->__pyx_n_s_sepainit); + Py_VISIT(traverse_module_state->__pyx_n_s_sepainitsol); + Py_VISIT(traverse_module_state->__pyx_n_s_sepapriority); + Py_VISIT(traverse_module_state->__pyx_n_s_separate); + Py_VISIT(traverse_module_state->__pyx_n_u_separate); + Py_VISIT(traverse_module_state->__pyx_n_s_separateSol); + Py_VISIT(traverse_module_state->__pyx_n_s_setBendersSubproblemIsConvex); + Py_VISIT(traverse_module_state->__pyx_n_s_setBoolParam); + Py_VISIT(traverse_module_state->__pyx_n_s_setCharParam); + Py_VISIT(traverse_module_state->__pyx_n_s_setCheck); + Py_VISIT(traverse_module_state->__pyx_n_s_setEmphasis); + Py_VISIT(traverse_module_state->__pyx_n_s_setEnforced); + Py_VISIT(traverse_module_state->__pyx_n_s_setHeuristics); + Py_VISIT(traverse_module_state->__pyx_n_s_setInitial); + Py_VISIT(traverse_module_state->__pyx_n_s_setIntParam); + Py_VISIT(traverse_module_state->__pyx_n_s_setLogfile); + Py_VISIT(traverse_module_state->__pyx_n_s_setLongintParam); + Py_VISIT(traverse_module_state->__pyx_n_s_setMaximize); + Py_VISIT(traverse_module_state->__pyx_n_s_setMinimize); + Py_VISIT(traverse_module_state->__pyx_n_s_setObjIntegral); + Py_VISIT(traverse_module_state->__pyx_n_s_setObjective); + Py_VISIT(traverse_module_state->__pyx_n_s_setObjlimit); + Py_VISIT(traverse_module_state->__pyx_n_s_setParam); + Py_VISIT(traverse_module_state->__pyx_n_s_setParams); + Py_VISIT(traverse_module_state->__pyx_n_s_setParamsCountsols); + Py_VISIT(traverse_module_state->__pyx_n_s_setPresolve); + Py_VISIT(traverse_module_state->__pyx_n_s_setProbName); + Py_VISIT(traverse_module_state->__pyx_n_s_setRealParam); + Py_VISIT(traverse_module_state->__pyx_n_s_setRelaxSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_setRemovable); + Py_VISIT(traverse_module_state->__pyx_n_s_setSeparating); + Py_VISIT(traverse_module_state->__pyx_n_s_setSolVal); + Py_VISIT(traverse_module_state->__pyx_n_s_setStringParam); + Py_VISIT(traverse_module_state->__pyx_n_s_set_name); + Py_VISIT(traverse_module_state->__pyx_n_s_setlocale); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_setting); + Py_VISIT(traverse_module_state->__pyx_n_s_setupBendersSubproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_shareaux); + Py_VISIT(traverse_module_state->__pyx_n_s_siblings); + Py_VISIT(traverse_module_state->__pyx_n_s_siblings_2); + Py_VISIT(traverse_module_state->__pyx_n_s_side); + Py_VISIT(traverse_module_state->__pyx_n_s_sin); + Py_VISIT(traverse_module_state->__pyx_n_u_sin); + Py_VISIT(traverse_module_state->__pyx_n_u_skipsolve); + Py_VISIT(traverse_module_state->__pyx_n_s_slots); + Py_VISIT(traverse_module_state->__pyx_n_s_sol); + Py_VISIT(traverse_module_state->__pyx_n_s_sol_2); + Py_VISIT(traverse_module_state->__pyx_n_s_solinfeasible); + Py_VISIT(traverse_module_state->__pyx_n_u_sollimit); + Py_VISIT(traverse_module_state->__pyx_n_s_solptr); + Py_VISIT(traverse_module_state->__pyx_n_s_sols); + Py_VISIT(traverse_module_state->__pyx_n_s_sols_2); + Py_VISIT(traverse_module_state->__pyx_n_s_solution); + Py_VISIT(traverse_module_state->__pyx_n_s_solutions); + Py_VISIT(traverse_module_state->__pyx_n_s_solve); + Py_VISIT(traverse_module_state->__pyx_n_s_solveBendersSubproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_solveConcurrent); + Py_VISIT(traverse_module_state->__pyx_n_s_solveDiveLP); + Py_VISIT(traverse_module_state->__pyx_n_s_solveProbingLP); + Py_VISIT(traverse_module_state->__pyx_n_s_solvecip); + Py_VISIT(traverse_module_state->__pyx_n_s_sorted); + Py_VISIT(traverse_module_state->__pyx_n_s_sourceModel); + Py_VISIT(traverse_module_state->__pyx_n_s_sourceconstraint); + Py_VISIT(traverse_module_state->__pyx_n_s_spec); + Py_VISIT(traverse_module_state->__pyx_n_s_splitext); + Py_VISIT(traverse_module_state->__pyx_n_s_sqrcoef); + Py_VISIT(traverse_module_state->__pyx_n_s_sqrexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_sqrt); + Py_VISIT(traverse_module_state->__pyx_n_u_sqrt); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_benders_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_benderscut_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_branchrule_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_conshdlr_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_cutsel_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_event_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_expr_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_heuristic_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_lp_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_nodesel_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_presol_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_pricer_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_propagator_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_reader_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_relax_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_scip_pxi); + Py_VISIT(traverse_module_state->__pyx_kp_s_src_pyscipopt_sepa_pxi); + Py_VISIT(traverse_module_state->__pyx_n_u_stallnodelimit); + Py_VISIT(traverse_module_state->__pyx_n_s_startDive); + Py_VISIT(traverse_module_state->__pyx_n_s_startProbing); + Py_VISIT(traverse_module_state->__pyx_n_s_startnconss); + Py_VISIT(traverse_module_state->__pyx_n_s_startnvars); + Py_VISIT(traverse_module_state->__pyx_n_s_stat); + Py_VISIT(traverse_module_state->__pyx_n_s_state); + Py_VISIT(traverse_module_state->__pyx_n_s_staticmethod); + Py_VISIT(traverse_module_state->__pyx_n_s_stderr); + Py_VISIT(traverse_module_state->__pyx_n_s_stdout); + Py_VISIT(traverse_module_state->__pyx_n_s_stdpriority); + Py_VISIT(traverse_module_state->__pyx_n_s_stickingatnode); + Py_VISIT(traverse_module_state->__pyx_n_u_stickingatnode); + Py_VISIT(traverse_module_state->__pyx_n_u_stopearly); + Py_VISIT(traverse_module_state->__pyx_n_s_stored); + Py_VISIT(traverse_module_state->__pyx_n_s_str_absfile); + Py_VISIT(traverse_module_state->__pyx_n_s_str_conversion); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_subprob); + Py_VISIT(traverse_module_state->__pyx_n_s_subproblem); + Py_VISIT(traverse_module_state->__pyx_n_s_subproblems); + Py_VISIT(traverse_module_state->__pyx_n_s_subprobs); + Py_VISIT(traverse_module_state->__pyx_n_s_success); + Py_VISIT(traverse_module_state->__pyx_n_u_success); + Py_VISIT(traverse_module_state->__pyx_n_s_sum); + Py_VISIT(traverse_module_state->__pyx_n_u_sum); + Py_VISIT(traverse_module_state->__pyx_n_s_sumexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_super); + Py_VISIT(traverse_module_state->__pyx_n_s_sys); + Py_VISIT(traverse_module_state->__pyx_n_s_t); + Py_VISIT(traverse_module_state->__pyx_n_s_take_ownership); + Py_VISIT(traverse_module_state->__pyx_n_u_targetcons); + Py_VISIT(traverse_module_state->__pyx_n_s_targetvalue); + Py_VISIT(traverse_module_state->__pyx_n_s_temp_cons); + Py_VISIT(traverse_module_state->__pyx_n_s_term); + Py_VISIT(traverse_module_state->__pyx_kp_u_term_length_must_be_1_or_2_but_i); + Py_VISIT(traverse_module_state->__pyx_n_s_termcoefs); + Py_VISIT(traverse_module_state->__pyx_n_s_termidx); + Py_VISIT(traverse_module_state->__pyx_n_s_termlist); + Py_VISIT(traverse_module_state->__pyx_n_s_terms); + Py_VISIT(traverse_module_state->__pyx_n_s_termvars); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_threadsafe); + Py_VISIT(traverse_module_state->__pyx_n_s_throw); + Py_VISIT(traverse_module_state->__pyx_n_s_tightenVarLb); + Py_VISIT(traverse_module_state->__pyx_n_s_tightenVarLbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_tightenVarUb); + Py_VISIT(traverse_module_state->__pyx_n_s_tightenVarUbGlobal); + Py_VISIT(traverse_module_state->__pyx_n_s_tightened); + Py_VISIT(traverse_module_state->__pyx_n_u_timelimit); + Py_VISIT(traverse_module_state->__pyx_n_s_timing); + Py_VISIT(traverse_module_state->__pyx_n_s_timingmask); + Py_VISIT(traverse_module_state->__pyx_n_s_tmp); + Py_VISIT(traverse_module_state->__pyx_n_s_to_ptr); + Py_VISIT(traverse_module_state->__pyx_kp_u_total_number_of_solutions_found); + Py_VISIT(traverse_module_state->__pyx_n_u_totalnodelimit); + Py_VISIT(traverse_module_state->__pyx_n_s_trans); + Py_VISIT(traverse_module_state->__pyx_n_s_transcons); + Py_VISIT(traverse_module_state->__pyx_n_s_transformed); + Py_VISIT(traverse_module_state->__pyx_kp_u_transprob_sol); + Py_VISIT(traverse_module_state->__pyx_n_u_true); + Py_VISIT(traverse_module_state->__pyx_n_s_truediv); + Py_VISIT(traverse_module_state->__pyx_n_s_trySol); + Py_VISIT(traverse_module_state->__pyx_n_s_tvar); + Py_VISIT(traverse_module_state->__pyx_n_s_typing); + Py_VISIT(traverse_module_state->__pyx_n_s_ub); + Py_VISIT(traverse_module_state->__pyx_n_s_ubs); + Py_VISIT(traverse_module_state->__pyx_n_u_unbounded); + Py_VISIT(traverse_module_state->__pyx_n_u_unknown); + Py_VISIT(traverse_module_state->__pyx_kp_u_unrecognized_objective_sense); + Py_VISIT(traverse_module_state->__pyx_kp_u_unrecognized_optimization_sense); + Py_VISIT(traverse_module_state->__pyx_kp_u_unrecognized_variable_type); + Py_VISIT(traverse_module_state->__pyx_n_s_upchild); + Py_VISIT(traverse_module_state->__pyx_n_s_update); + Py_VISIT(traverse_module_state->__pyx_n_s_updateBendersLowerbounds); + Py_VISIT(traverse_module_state->__pyx_n_s_updateNodeLowerbound); + Py_VISIT(traverse_module_state->__pyx_n_s_upper); + Py_VISIT(traverse_module_state->__pyx_n_u_upper); + Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_user_locale); + Py_VISIT(traverse_module_state->__pyx_n_u_userinterrupt); + Py_VISIT(traverse_module_state->__pyx_n_s_usessubscip); + Py_VISIT(traverse_module_state->__pyx_kp_u_utf_8); + Py_VISIT(traverse_module_state->__pyx_n_s_v); + Py_VISIT(traverse_module_state->__pyx_n_s_val); + Py_VISIT(traverse_module_state->__pyx_n_s_val1); + Py_VISIT(traverse_module_state->__pyx_n_s_val2); + Py_VISIT(traverse_module_state->__pyx_n_s_valid); + Py_VISIT(traverse_module_state->__pyx_n_s_validnode); + Py_VISIT(traverse_module_state->__pyx_n_s_vals); + Py_VISIT(traverse_module_state->__pyx_n_s_vals_2); + Py_VISIT(traverse_module_state->__pyx_n_s_valsdict); + Py_VISIT(traverse_module_state->__pyx_n_s_value); + Py_VISIT(traverse_module_state->__pyx_n_s_value_to_array); + Py_VISIT(traverse_module_state->__pyx_n_s_valuenode); + Py_VISIT(traverse_module_state->__pyx_n_s_values); + Py_VISIT(traverse_module_state->__pyx_n_s_var); + Py_VISIT(traverse_module_state->__pyx_n_u_var); + Py_VISIT(traverse_module_state->__pyx_n_s_var1); + Py_VISIT(traverse_module_state->__pyx_n_s_var2); + Py_VISIT(traverse_module_state->__pyx_n_s_var_2); + Py_VISIT(traverse_module_state->__pyx_n_s_var_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_varexpr); + Py_VISIT(traverse_module_state->__pyx_n_s_varexprs); + Py_VISIT(traverse_module_state->__pyx_n_s_variable); + Py_VISIT(traverse_module_state->__pyx_n_s_variables); + Py_VISIT(traverse_module_state->__pyx_n_s_varidx); + Py_VISIT(traverse_module_state->__pyx_n_s_varindex); + Py_VISIT(traverse_module_state->__pyx_n_s_varpos); + Py_VISIT(traverse_module_state->__pyx_n_s_vars); + Py_VISIT(traverse_module_state->__pyx_n_s_vars_2); + Py_VISIT(traverse_module_state->__pyx_n_s_vars_array); + Py_VISIT(traverse_module_state->__pyx_n_s_vartuple); + Py_VISIT(traverse_module_state->__pyx_n_u_vartuple); + Py_VISIT(traverse_module_state->__pyx_n_s_vartype); + Py_VISIT(traverse_module_state->__pyx_n_s_verbose); + Py_VISIT(traverse_module_state->__pyx_n_s_version); + Py_VISIT(traverse_module_state->__pyx_n_s_version_info); + Py_VISIT(traverse_module_state->__pyx_n_s_vtype); + Py_VISIT(traverse_module_state->__pyx_n_u_w); + Py_VISIT(traverse_module_state->__pyx_n_s_warn); + Py_VISIT(traverse_module_state->__pyx_n_s_warnings); + Py_VISIT(traverse_module_state->__pyx_n_s_weakref); + Py_VISIT(traverse_module_state->__pyx_n_s_weight); + Py_VISIT(traverse_module_state->__pyx_n_s_weights); + Py_VISIT(traverse_module_state->__pyx_n_s_write); + Py_VISIT(traverse_module_state->__pyx_n_s_writeBestSol); + Py_VISIT(traverse_module_state->__pyx_n_s_writeBestTransSol); + Py_VISIT(traverse_module_state->__pyx_n_s_writeLP); + Py_VISIT(traverse_module_state->__pyx_n_s_writeName); + Py_VISIT(traverse_module_state->__pyx_n_s_writeParams); + Py_VISIT(traverse_module_state->__pyx_n_s_writeProblem); + Py_VISIT(traverse_module_state->__pyx_n_s_writeSol); + Py_VISIT(traverse_module_state->__pyx_n_s_writeStatistics); + Py_VISIT(traverse_module_state->__pyx_n_s_writeTransSol); + Py_VISIT(traverse_module_state->__pyx_n_s_write_zeros); + Py_VISIT(traverse_module_state->__pyx_kp_u_wrote_parameter_settings_to_file); + Py_VISIT(traverse_module_state->__pyx_kp_u_wrote_problem_to_file); + Py_VISIT(traverse_module_state->__pyx_n_s_x); + Py_VISIT(traverse_module_state->__pyx_n_u_x); + Py_VISIT(traverse_module_state->__pyx_n_u_zero); + Py_VISIT(traverse_module_state->__pyx_float_0_0); + Py_VISIT(traverse_module_state->__pyx_float_1_0); + Py_VISIT(traverse_module_state->__pyx_float_10_0); + Py_VISIT(traverse_module_state->__pyx_float_100_0); + Py_VISIT(traverse_module_state->__pyx_float_1e_20); + Py_VISIT(traverse_module_state->__pyx_float_neg_1_0); + Py_VISIT(traverse_module_state->__pyx_int_0); + Py_VISIT(traverse_module_state->__pyx_int_1); + Py_VISIT(traverse_module_state->__pyx_int_2); + Py_VISIT(traverse_module_state->__pyx_int_3); + Py_VISIT(traverse_module_state->__pyx_int_5); + Py_VISIT(traverse_module_state->__pyx_int_9); + Py_VISIT(traverse_module_state->__pyx_int_10); + Py_VISIT(traverse_module_state->__pyx_int_100); + Py_VISIT(traverse_module_state->__pyx_int_101); + Py_VISIT(traverse_module_state->__pyx_int_10000); + Py_VISIT(traverse_module_state->__pyx_int_13758880); + Py_VISIT(traverse_module_state->__pyx_int_25280761); + Py_VISIT(traverse_module_state->__pyx_int_30435853); + Py_VISIT(traverse_module_state->__pyx_int_34551270); + Py_VISIT(traverse_module_state->__pyx_int_37557029); + Py_VISIT(traverse_module_state->__pyx_int_63254455); + Py_VISIT(traverse_module_state->__pyx_int_76513566); + Py_VISIT(traverse_module_state->__pyx_int_76998962); + Py_VISIT(traverse_module_state->__pyx_int_80720285); + Py_VISIT(traverse_module_state->__pyx_int_85795681); + Py_VISIT(traverse_module_state->__pyx_int_95355963); + Py_VISIT(traverse_module_state->__pyx_int_114651189); + Py_VISIT(traverse_module_state->__pyx_int_116691903); + Py_VISIT(traverse_module_state->__pyx_int_132603380); + Py_VISIT(traverse_module_state->__pyx_int_135158539); + Py_VISIT(traverse_module_state->__pyx_int_143015212); + Py_VISIT(traverse_module_state->__pyx_int_147635180); + Py_VISIT(traverse_module_state->__pyx_int_150239579); + Py_VISIT(traverse_module_state->__pyx_int_152146234); + Py_VISIT(traverse_module_state->__pyx_int_154610759); + Py_VISIT(traverse_module_state->__pyx_int_169888372); + Py_VISIT(traverse_module_state->__pyx_int_173957064); + Py_VISIT(traverse_module_state->__pyx_int_176834982); + Py_VISIT(traverse_module_state->__pyx_int_201230365); + Py_VISIT(traverse_module_state->__pyx_int_204489503); + Py_VISIT(traverse_module_state->__pyx_int_208012509); + Py_VISIT(traverse_module_state->__pyx_int_208195651); + Py_VISIT(traverse_module_state->__pyx_int_214626690); + Py_VISIT(traverse_module_state->__pyx_int_216408278); + Py_VISIT(traverse_module_state->__pyx_int_222419149); + Py_VISIT(traverse_module_state->__pyx_int_228825662); + Py_VISIT(traverse_module_state->__pyx_int_238750788); + Py_VISIT(traverse_module_state->__pyx_int_240430858); + Py_VISIT(traverse_module_state->__pyx_int_248330301); + Py_VISIT(traverse_module_state->__pyx_int_253686829); + Py_VISIT(traverse_module_state->__pyx_int_267356384); + Py_VISIT(traverse_module_state->__pyx_int_neg_1); + Py_VISIT(traverse_module_state->__pyx_k__101); + Py_VISIT(traverse_module_state->__pyx_k__102); + Py_VISIT(traverse_module_state->__pyx_k__103); + Py_VISIT(traverse_module_state->__pyx_k__104); + Py_VISIT(traverse_module_state->__pyx_k__105); + Py_VISIT(traverse_module_state->__pyx_k__106); + Py_VISIT(traverse_module_state->__pyx_tuple_); + Py_VISIT(traverse_module_state->__pyx_tuple__3); + Py_VISIT(traverse_module_state->__pyx_tuple__4); + Py_VISIT(traverse_module_state->__pyx_tuple__5); + Py_VISIT(traverse_module_state->__pyx_tuple__7); + Py_VISIT(traverse_module_state->__pyx_tuple__8); + Py_VISIT(traverse_module_state->__pyx_slice__88); + Py_VISIT(traverse_module_state->__pyx_tuple__11); + Py_VISIT(traverse_module_state->__pyx_tuple__12); + Py_VISIT(traverse_module_state->__pyx_tuple__13); + Py_VISIT(traverse_module_state->__pyx_tuple__14); + Py_VISIT(traverse_module_state->__pyx_tuple__15); + Py_VISIT(traverse_module_state->__pyx_tuple__16); + Py_VISIT(traverse_module_state->__pyx_tuple__17); + Py_VISIT(traverse_module_state->__pyx_tuple__18); + Py_VISIT(traverse_module_state->__pyx_tuple__19); + Py_VISIT(traverse_module_state->__pyx_tuple__20); + Py_VISIT(traverse_module_state->__pyx_tuple__21); + Py_VISIT(traverse_module_state->__pyx_tuple__22); + Py_VISIT(traverse_module_state->__pyx_tuple__23); + Py_VISIT(traverse_module_state->__pyx_tuple__24); + Py_VISIT(traverse_module_state->__pyx_tuple__25); + Py_VISIT(traverse_module_state->__pyx_tuple__26); + Py_VISIT(traverse_module_state->__pyx_tuple__27); + Py_VISIT(traverse_module_state->__pyx_tuple__28); + Py_VISIT(traverse_module_state->__pyx_tuple__29); + Py_VISIT(traverse_module_state->__pyx_tuple__30); + Py_VISIT(traverse_module_state->__pyx_tuple__31); + Py_VISIT(traverse_module_state->__pyx_tuple__32); + Py_VISIT(traverse_module_state->__pyx_tuple__33); + Py_VISIT(traverse_module_state->__pyx_tuple__34); + Py_VISIT(traverse_module_state->__pyx_tuple__35); + Py_VISIT(traverse_module_state->__pyx_tuple__36); + Py_VISIT(traverse_module_state->__pyx_tuple__37); + Py_VISIT(traverse_module_state->__pyx_tuple__38); + Py_VISIT(traverse_module_state->__pyx_tuple__39); + Py_VISIT(traverse_module_state->__pyx_tuple__40); + Py_VISIT(traverse_module_state->__pyx_tuple__41); + Py_VISIT(traverse_module_state->__pyx_tuple__42); + Py_VISIT(traverse_module_state->__pyx_tuple__43); + Py_VISIT(traverse_module_state->__pyx_tuple__44); + Py_VISIT(traverse_module_state->__pyx_tuple__45); + Py_VISIT(traverse_module_state->__pyx_tuple__46); + Py_VISIT(traverse_module_state->__pyx_tuple__47); + Py_VISIT(traverse_module_state->__pyx_tuple__48); + Py_VISIT(traverse_module_state->__pyx_tuple__49); + Py_VISIT(traverse_module_state->__pyx_tuple__50); + Py_VISIT(traverse_module_state->__pyx_tuple__51); + Py_VISIT(traverse_module_state->__pyx_tuple__52); + Py_VISIT(traverse_module_state->__pyx_tuple__53); + Py_VISIT(traverse_module_state->__pyx_tuple__54); + Py_VISIT(traverse_module_state->__pyx_tuple__55); + Py_VISIT(traverse_module_state->__pyx_tuple__56); + Py_VISIT(traverse_module_state->__pyx_tuple__57); + Py_VISIT(traverse_module_state->__pyx_tuple__58); + Py_VISIT(traverse_module_state->__pyx_tuple__59); + Py_VISIT(traverse_module_state->__pyx_tuple__60); + Py_VISIT(traverse_module_state->__pyx_tuple__61); + Py_VISIT(traverse_module_state->__pyx_tuple__62); + Py_VISIT(traverse_module_state->__pyx_tuple__63); + Py_VISIT(traverse_module_state->__pyx_tuple__64); + Py_VISIT(traverse_module_state->__pyx_tuple__65); + Py_VISIT(traverse_module_state->__pyx_tuple__66); + Py_VISIT(traverse_module_state->__pyx_tuple__67); + Py_VISIT(traverse_module_state->__pyx_tuple__68); + Py_VISIT(traverse_module_state->__pyx_tuple__69); + Py_VISIT(traverse_module_state->__pyx_tuple__70); + Py_VISIT(traverse_module_state->__pyx_tuple__71); + Py_VISIT(traverse_module_state->__pyx_tuple__72); + Py_VISIT(traverse_module_state->__pyx_tuple__73); + Py_VISIT(traverse_module_state->__pyx_tuple__74); + Py_VISIT(traverse_module_state->__pyx_tuple__75); + Py_VISIT(traverse_module_state->__pyx_tuple__76); + Py_VISIT(traverse_module_state->__pyx_tuple__77); + Py_VISIT(traverse_module_state->__pyx_tuple__78); + Py_VISIT(traverse_module_state->__pyx_tuple__80); + Py_VISIT(traverse_module_state->__pyx_tuple__81); + Py_VISIT(traverse_module_state->__pyx_tuple__82); + Py_VISIT(traverse_module_state->__pyx_tuple__83); + Py_VISIT(traverse_module_state->__pyx_tuple__84); + Py_VISIT(traverse_module_state->__pyx_tuple__85); + Py_VISIT(traverse_module_state->__pyx_tuple__86); + Py_VISIT(traverse_module_state->__pyx_tuple__87); + Py_VISIT(traverse_module_state->__pyx_tuple__90); + Py_VISIT(traverse_module_state->__pyx_tuple__91); + Py_VISIT(traverse_module_state->__pyx_tuple__92); + Py_VISIT(traverse_module_state->__pyx_tuple__96); + Py_VISIT(traverse_module_state->__pyx_tuple__97); + Py_VISIT(traverse_module_state->__pyx_tuple__98); + Py_VISIT(traverse_module_state->__pyx_tuple__99); + Py_VISIT(traverse_module_state->__pyx_tuple__100); + Py_VISIT(traverse_module_state->__pyx_tuple__107); + Py_VISIT(traverse_module_state->__pyx_tuple__108); + Py_VISIT(traverse_module_state->__pyx_tuple__109); + Py_VISIT(traverse_module_state->__pyx_tuple__110); + Py_VISIT(traverse_module_state->__pyx_tuple__111); + Py_VISIT(traverse_module_state->__pyx_tuple__112); + Py_VISIT(traverse_module_state->__pyx_tuple__113); + Py_VISIT(traverse_module_state->__pyx_tuple__115); + Py_VISIT(traverse_module_state->__pyx_tuple__116); + Py_VISIT(traverse_module_state->__pyx_tuple__117); + Py_VISIT(traverse_module_state->__pyx_tuple__118); + Py_VISIT(traverse_module_state->__pyx_tuple__119); + Py_VISIT(traverse_module_state->__pyx_tuple__120); + Py_VISIT(traverse_module_state->__pyx_tuple__121); + Py_VISIT(traverse_module_state->__pyx_tuple__122); + Py_VISIT(traverse_module_state->__pyx_tuple__123); + Py_VISIT(traverse_module_state->__pyx_tuple__124); + Py_VISIT(traverse_module_state->__pyx_tuple__125); + Py_VISIT(traverse_module_state->__pyx_tuple__127); + Py_VISIT(traverse_module_state->__pyx_tuple__129); + Py_VISIT(traverse_module_state->__pyx_tuple__131); + Py_VISIT(traverse_module_state->__pyx_tuple__132); + Py_VISIT(traverse_module_state->__pyx_tuple__134); + Py_VISIT(traverse_module_state->__pyx_tuple__136); + Py_VISIT(traverse_module_state->__pyx_tuple__138); + Py_VISIT(traverse_module_state->__pyx_tuple__141); + Py_VISIT(traverse_module_state->__pyx_tuple__143); + Py_VISIT(traverse_module_state->__pyx_tuple__145); + Py_VISIT(traverse_module_state->__pyx_tuple__147); + Py_VISIT(traverse_module_state->__pyx_tuple__149); + Py_VISIT(traverse_module_state->__pyx_tuple__151); + Py_VISIT(traverse_module_state->__pyx_tuple__153); + Py_VISIT(traverse_module_state->__pyx_tuple__155); + Py_VISIT(traverse_module_state->__pyx_tuple__159); + Py_VISIT(traverse_module_state->__pyx_tuple__182); + Py_VISIT(traverse_module_state->__pyx_tuple__188); + Py_VISIT(traverse_module_state->__pyx_tuple__190); + Py_VISIT(traverse_module_state->__pyx_tuple__192); + Py_VISIT(traverse_module_state->__pyx_tuple__194); + Py_VISIT(traverse_module_state->__pyx_tuple__198); + Py_VISIT(traverse_module_state->__pyx_tuple__200); + Py_VISIT(traverse_module_state->__pyx_tuple__202); + Py_VISIT(traverse_module_state->__pyx_tuple__203); + Py_VISIT(traverse_module_state->__pyx_tuple__205); + Py_VISIT(traverse_module_state->__pyx_tuple__207); + Py_VISIT(traverse_module_state->__pyx_tuple__209); + Py_VISIT(traverse_module_state->__pyx_tuple__210); + Py_VISIT(traverse_module_state->__pyx_tuple__212); + Py_VISIT(traverse_module_state->__pyx_tuple__213); + Py_VISIT(traverse_module_state->__pyx_tuple__215); + Py_VISIT(traverse_module_state->__pyx_tuple__217); + Py_VISIT(traverse_module_state->__pyx_tuple__218); + Py_VISIT(traverse_module_state->__pyx_tuple__220); + Py_VISIT(traverse_module_state->__pyx_tuple__222); + Py_VISIT(traverse_module_state->__pyx_tuple__224); + Py_VISIT(traverse_module_state->__pyx_tuple__226); + Py_VISIT(traverse_module_state->__pyx_tuple__229); + Py_VISIT(traverse_module_state->__pyx_tuple__231); + Py_VISIT(traverse_module_state->__pyx_tuple__233); + Py_VISIT(traverse_module_state->__pyx_tuple__235); + Py_VISIT(traverse_module_state->__pyx_tuple__238); + Py_VISIT(traverse_module_state->__pyx_tuple__241); + Py_VISIT(traverse_module_state->__pyx_tuple__243); + Py_VISIT(traverse_module_state->__pyx_tuple__245); + Py_VISIT(traverse_module_state->__pyx_tuple__247); + Py_VISIT(traverse_module_state->__pyx_tuple__249); + Py_VISIT(traverse_module_state->__pyx_tuple__260); + Py_VISIT(traverse_module_state->__pyx_tuple__262); + Py_VISIT(traverse_module_state->__pyx_tuple__264); + Py_VISIT(traverse_module_state->__pyx_tuple__266); + Py_VISIT(traverse_module_state->__pyx_tuple__268); + Py_VISIT(traverse_module_state->__pyx_tuple__271); + Py_VISIT(traverse_module_state->__pyx_tuple__280); + Py_VISIT(traverse_module_state->__pyx_tuple__289); + Py_VISIT(traverse_module_state->__pyx_tuple__296); + Py_VISIT(traverse_module_state->__pyx_tuple__302); + Py_VISIT(traverse_module_state->__pyx_tuple__304); + Py_VISIT(traverse_module_state->__pyx_tuple__306); + Py_VISIT(traverse_module_state->__pyx_tuple__309); + Py_VISIT(traverse_module_state->__pyx_tuple__311); + Py_VISIT(traverse_module_state->__pyx_tuple__313); + Py_VISIT(traverse_module_state->__pyx_tuple__315); + Py_VISIT(traverse_module_state->__pyx_tuple__317); + Py_VISIT(traverse_module_state->__pyx_tuple__319); + Py_VISIT(traverse_module_state->__pyx_tuple__321); + Py_VISIT(traverse_module_state->__pyx_tuple__323); + Py_VISIT(traverse_module_state->__pyx_tuple__326); + Py_VISIT(traverse_module_state->__pyx_tuple__348); + Py_VISIT(traverse_module_state->__pyx_tuple__359); + Py_VISIT(traverse_module_state->__pyx_tuple__368); + Py_VISIT(traverse_module_state->__pyx_tuple__377); + Py_VISIT(traverse_module_state->__pyx_tuple__394); + Py_VISIT(traverse_module_state->__pyx_tuple__398); + Py_VISIT(traverse_module_state->__pyx_tuple__400); + Py_VISIT(traverse_module_state->__pyx_tuple__402); + Py_VISIT(traverse_module_state->__pyx_tuple__412); + Py_VISIT(traverse_module_state->__pyx_tuple__418); + Py_VISIT(traverse_module_state->__pyx_tuple__436); + Py_VISIT(traverse_module_state->__pyx_tuple__440); + Py_VISIT(traverse_module_state->__pyx_tuple__471); + Py_VISIT(traverse_module_state->__pyx_tuple__475); + Py_VISIT(traverse_module_state->__pyx_tuple__479); + Py_VISIT(traverse_module_state->__pyx_tuple__481); + Py_VISIT(traverse_module_state->__pyx_tuple__483); + Py_VISIT(traverse_module_state->__pyx_tuple__488); + Py_VISIT(traverse_module_state->__pyx_tuple__509); + Py_VISIT(traverse_module_state->__pyx_tuple__513); + Py_VISIT(traverse_module_state->__pyx_tuple__515); + Py_VISIT(traverse_module_state->__pyx_tuple__521); + Py_VISIT(traverse_module_state->__pyx_tuple__528); + Py_VISIT(traverse_module_state->__pyx_tuple__530); + Py_VISIT(traverse_module_state->__pyx_tuple__541); + Py_VISIT(traverse_module_state->__pyx_tuple__551); + Py_VISIT(traverse_module_state->__pyx_tuple__556); + Py_VISIT(traverse_module_state->__pyx_tuple__558); + Py_VISIT(traverse_module_state->__pyx_tuple__560); + Py_VISIT(traverse_module_state->__pyx_tuple__562); + Py_VISIT(traverse_module_state->__pyx_tuple__567); + Py_VISIT(traverse_module_state->__pyx_tuple__572); + Py_VISIT(traverse_module_state->__pyx_tuple__596); + Py_VISIT(traverse_module_state->__pyx_tuple__602); + Py_VISIT(traverse_module_state->__pyx_tuple__604); + Py_VISIT(traverse_module_state->__pyx_tuple__607); + Py_VISIT(traverse_module_state->__pyx_tuple__609); + Py_VISIT(traverse_module_state->__pyx_tuple__611); + Py_VISIT(traverse_module_state->__pyx_tuple__614); + Py_VISIT(traverse_module_state->__pyx_tuple__636); + Py_VISIT(traverse_module_state->__pyx_tuple__644); + Py_VISIT(traverse_module_state->__pyx_tuple__651); + Py_VISIT(traverse_module_state->__pyx_tuple__653); + Py_VISIT(traverse_module_state->__pyx_tuple__654); + Py_VISIT(traverse_module_state->__pyx_tuple__656); + Py_VISIT(traverse_module_state->__pyx_tuple__660); + Py_VISIT(traverse_module_state->__pyx_tuple__663); + Py_VISIT(traverse_module_state->__pyx_tuple__665); + Py_VISIT(traverse_module_state->__pyx_tuple__666); + Py_VISIT(traverse_module_state->__pyx_tuple__668); + Py_VISIT(traverse_module_state->__pyx_tuple__670); + Py_VISIT(traverse_module_state->__pyx_tuple__674); + Py_VISIT(traverse_module_state->__pyx_tuple__676); + Py_VISIT(traverse_module_state->__pyx_tuple__680); + Py_VISIT(traverse_module_state->__pyx_tuple__682); + Py_VISIT(traverse_module_state->__pyx_tuple__684); + Py_VISIT(traverse_module_state->__pyx_tuple__685); + Py_VISIT(traverse_module_state->__pyx_tuple__687); + Py_VISIT(traverse_module_state->__pyx_tuple__688); + Py_VISIT(traverse_module_state->__pyx_tuple__690); + Py_VISIT(traverse_module_state->__pyx_tuple__692); + Py_VISIT(traverse_module_state->__pyx_tuple__694); + Py_VISIT(traverse_module_state->__pyx_tuple__696); + Py_VISIT(traverse_module_state->__pyx_tuple__698); + Py_VISIT(traverse_module_state->__pyx_tuple__702); + Py_VISIT(traverse_module_state->__pyx_tuple__704); + Py_VISIT(traverse_module_state->__pyx_tuple__708); + Py_VISIT(traverse_module_state->__pyx_tuple__710); + Py_VISIT(traverse_module_state->__pyx_tuple__712); + Py_VISIT(traverse_module_state->__pyx_tuple__714); + Py_VISIT(traverse_module_state->__pyx_tuple__716); + Py_VISIT(traverse_module_state->__pyx_tuple__720); + Py_VISIT(traverse_module_state->__pyx_tuple__722); + Py_VISIT(traverse_module_state->__pyx_tuple__730); + Py_VISIT(traverse_module_state->__pyx_tuple__734); + Py_VISIT(traverse_module_state->__pyx_tuple__737); + Py_VISIT(traverse_module_state->__pyx_tuple__739); + Py_VISIT(traverse_module_state->__pyx_tuple__743); + Py_VISIT(traverse_module_state->__pyx_tuple__745); + Py_VISIT(traverse_module_state->__pyx_tuple__747); + Py_VISIT(traverse_module_state->__pyx_tuple__750); + Py_VISIT(traverse_module_state->__pyx_tuple__752); + Py_VISIT(traverse_module_state->__pyx_tuple__753); + Py_VISIT(traverse_module_state->__pyx_tuple__760); + Py_VISIT(traverse_module_state->__pyx_tuple__765); + Py_VISIT(traverse_module_state->__pyx_tuple__767); + Py_VISIT(traverse_module_state->__pyx_tuple__770); + Py_VISIT(traverse_module_state->__pyx_tuple__772); + Py_VISIT(traverse_module_state->__pyx_tuple__775); + Py_VISIT(traverse_module_state->__pyx_tuple__780); + Py_VISIT(traverse_module_state->__pyx_tuple__782); + Py_VISIT(traverse_module_state->__pyx_tuple__783); + Py_VISIT(traverse_module_state->__pyx_tuple__785); + Py_VISIT(traverse_module_state->__pyx_tuple__787); + Py_VISIT(traverse_module_state->__pyx_tuple__789); + Py_VISIT(traverse_module_state->__pyx_tuple__791); + Py_VISIT(traverse_module_state->__pyx_tuple__793); + Py_VISIT(traverse_module_state->__pyx_tuple__794); + Py_VISIT(traverse_module_state->__pyx_tuple__796); + Py_VISIT(traverse_module_state->__pyx_tuple__798); + Py_VISIT(traverse_module_state->__pyx_tuple__800); + Py_VISIT(traverse_module_state->__pyx_tuple__801); + Py_VISIT(traverse_module_state->__pyx_tuple__803); + Py_VISIT(traverse_module_state->__pyx_tuple__805); + Py_VISIT(traverse_module_state->__pyx_tuple__808); + Py_VISIT(traverse_module_state->__pyx_tuple__810); + Py_VISIT(traverse_module_state->__pyx_tuple__812); + Py_VISIT(traverse_module_state->__pyx_tuple__814); + Py_VISIT(traverse_module_state->__pyx_tuple__816); + Py_VISIT(traverse_module_state->__pyx_tuple__818); + Py_VISIT(traverse_module_state->__pyx_tuple__820); + Py_VISIT(traverse_module_state->__pyx_tuple__821); + Py_VISIT(traverse_module_state->__pyx_tuple__823); + Py_VISIT(traverse_module_state->__pyx_tuple__825); + Py_VISIT(traverse_module_state->__pyx_tuple__826); + Py_VISIT(traverse_module_state->__pyx_tuple__828); + Py_VISIT(traverse_module_state->__pyx_tuple__829); + Py_VISIT(traverse_module_state->__pyx_tuple__831); + Py_VISIT(traverse_module_state->__pyx_tuple__832); + Py_VISIT(traverse_module_state->__pyx_tuple__834); + Py_VISIT(traverse_module_state->__pyx_tuple__835); + Py_VISIT(traverse_module_state->__pyx_tuple__837); + Py_VISIT(traverse_module_state->__pyx_tuple__839); + Py_VISIT(traverse_module_state->__pyx_tuple__844); + Py_VISIT(traverse_module_state->__pyx_tuple__846); + Py_VISIT(traverse_module_state->__pyx_tuple__848); + Py_VISIT(traverse_module_state->__pyx_tuple__850); + Py_VISIT(traverse_module_state->__pyx_tuple__852); + Py_VISIT(traverse_module_state->__pyx_tuple__854); + Py_VISIT(traverse_module_state->__pyx_tuple__856); + Py_VISIT(traverse_module_state->__pyx_tuple__859); + Py_VISIT(traverse_module_state->__pyx_tuple__863); + Py_VISIT(traverse_module_state->__pyx_tuple__865); + Py_VISIT(traverse_module_state->__pyx_tuple__867); + Py_VISIT(traverse_module_state->__pyx_tuple__871); + Py_VISIT(traverse_module_state->__pyx_tuple__873); + Py_VISIT(traverse_module_state->__pyx_tuple__875); + Py_VISIT(traverse_module_state->__pyx_tuple__877); + Py_VISIT(traverse_module_state->__pyx_tuple__879); + Py_VISIT(traverse_module_state->__pyx_tuple__881); + Py_VISIT(traverse_module_state->__pyx_tuple__883); + Py_VISIT(traverse_module_state->__pyx_tuple__885); + Py_VISIT(traverse_module_state->__pyx_tuple__887); + Py_VISIT(traverse_module_state->__pyx_tuple__892); + Py_VISIT(traverse_module_state->__pyx_tuple__894); + Py_VISIT(traverse_module_state->__pyx_tuple__896); + Py_VISIT(traverse_module_state->__pyx_tuple__900); + Py_VISIT(traverse_module_state->__pyx_tuple__902); + Py_VISIT(traverse_module_state->__pyx_tuple__907); + Py_VISIT(traverse_module_state->__pyx_tuple__909); + Py_VISIT(traverse_module_state->__pyx_tuple__911); + Py_VISIT(traverse_module_state->__pyx_tuple__913); + Py_VISIT(traverse_module_state->__pyx_tuple__915); + Py_VISIT(traverse_module_state->__pyx_tuple__917); + Py_VISIT(traverse_module_state->__pyx_tuple__919); + Py_VISIT(traverse_module_state->__pyx_tuple__921); + Py_VISIT(traverse_module_state->__pyx_tuple__923); + Py_VISIT(traverse_module_state->__pyx_tuple__925); + Py_VISIT(traverse_module_state->__pyx_tuple__927); + Py_VISIT(traverse_module_state->__pyx_tuple__929); + Py_VISIT(traverse_module_state->__pyx_tuple__930); + Py_VISIT(traverse_module_state->__pyx_tuple__932); + Py_VISIT(traverse_module_state->__pyx_tuple__934); + Py_VISIT(traverse_module_state->__pyx_tuple__936); + Py_VISIT(traverse_module_state->__pyx_tuple__938); + Py_VISIT(traverse_module_state->__pyx_tuple__940); + Py_VISIT(traverse_module_state->__pyx_tuple__941); + Py_VISIT(traverse_module_state->__pyx_tuple__943); + Py_VISIT(traverse_module_state->__pyx_tuple__945); + Py_VISIT(traverse_module_state->__pyx_tuple__946); + Py_VISIT(traverse_module_state->__pyx_tuple__948); + Py_VISIT(traverse_module_state->__pyx_tuple__950); + Py_VISIT(traverse_module_state->__pyx_tuple__951); + Py_VISIT(traverse_module_state->__pyx_tuple__953); + Py_VISIT(traverse_module_state->__pyx_tuple__955); + Py_VISIT(traverse_module_state->__pyx_tuple__957); + Py_VISIT(traverse_module_state->__pyx_tuple__959); + Py_VISIT(traverse_module_state->__pyx_tuple__960); + Py_VISIT(traverse_module_state->__pyx_tuple__962); + Py_VISIT(traverse_module_state->__pyx_tuple__964); + Py_VISIT(traverse_module_state->__pyx_tuple__966); + Py_VISIT(traverse_module_state->__pyx_tuple__968); + Py_VISIT(traverse_module_state->__pyx_tuple__969); + Py_VISIT(traverse_module_state->__pyx_tuple__971); + Py_VISIT(traverse_module_state->__pyx_tuple__973); + Py_VISIT(traverse_module_state->__pyx_tuple__975); + Py_VISIT(traverse_module_state->__pyx_tuple__977); + Py_VISIT(traverse_module_state->__pyx_tuple__979); + Py_VISIT(traverse_module_state->__pyx_tuple__981); + Py_VISIT(traverse_module_state->__pyx_tuple__983); + Py_VISIT(traverse_module_state->__pyx_tuple__987); + Py_VISIT(traverse_module_state->__pyx_tuple__989); + Py_VISIT(traverse_module_state->__pyx_tuple__994); + Py_VISIT(traverse_module_state->__pyx_tuple__996); + Py_VISIT(traverse_module_state->__pyx_tuple__999); + Py_VISIT(traverse_module_state->__pyx_codeobj__93); + Py_VISIT(traverse_module_state->__pyx_codeobj__95); + Py_VISIT(traverse_module_state->__pyx_tuple__1001); + Py_VISIT(traverse_module_state->__pyx_tuple__1006); + Py_VISIT(traverse_module_state->__pyx_tuple__1012); + Py_VISIT(traverse_module_state->__pyx_tuple__1018); + Py_VISIT(traverse_module_state->__pyx_tuple__1022); + Py_VISIT(traverse_module_state->__pyx_tuple__1024); + Py_VISIT(traverse_module_state->__pyx_tuple__1025); + Py_VISIT(traverse_module_state->__pyx_tuple__1027); + Py_VISIT(traverse_module_state->__pyx_tuple__1030); + Py_VISIT(traverse_module_state->__pyx_tuple__1032); + Py_VISIT(traverse_module_state->__pyx_tuple__1034); + Py_VISIT(traverse_module_state->__pyx_tuple__1035); + Py_VISIT(traverse_module_state->__pyx_tuple__1037); + Py_VISIT(traverse_module_state->__pyx_tuple__1039); + Py_VISIT(traverse_module_state->__pyx_tuple__1040); + Py_VISIT(traverse_module_state->__pyx_tuple__1044); + Py_VISIT(traverse_module_state->__pyx_tuple__1046); + Py_VISIT(traverse_module_state->__pyx_tuple__1048); + Py_VISIT(traverse_module_state->__pyx_tuple__1050); + Py_VISIT(traverse_module_state->__pyx_tuple__1051); + Py_VISIT(traverse_module_state->__pyx_tuple__1053); + Py_VISIT(traverse_module_state->__pyx_tuple__1054); + Py_VISIT(traverse_module_state->__pyx_tuple__1061); + Py_VISIT(traverse_module_state->__pyx_tuple__1064); + Py_VISIT(traverse_module_state->__pyx_tuple__1066); + Py_VISIT(traverse_module_state->__pyx_tuple__1069); + Py_VISIT(traverse_module_state->__pyx_tuple__1071); + Py_VISIT(traverse_module_state->__pyx_tuple__1075); + Py_VISIT(traverse_module_state->__pyx_tuple__1080); + Py_VISIT(traverse_module_state->__pyx_tuple__1086); + Py_VISIT(traverse_module_state->__pyx_tuple__1088); + Py_VISIT(traverse_module_state->__pyx_tuple__1091); + Py_VISIT(traverse_module_state->__pyx_tuple__1094); + Py_VISIT(traverse_module_state->__pyx_tuple__1098); + Py_VISIT(traverse_module_state->__pyx_tuple__1100); + Py_VISIT(traverse_module_state->__pyx_tuple__1102); + Py_VISIT(traverse_module_state->__pyx_tuple__1104); + Py_VISIT(traverse_module_state->__pyx_tuple__1106); + Py_VISIT(traverse_module_state->__pyx_tuple__1108); + Py_VISIT(traverse_module_state->__pyx_tuple__1114); + Py_VISIT(traverse_module_state->__pyx_tuple__1116); + Py_VISIT(traverse_module_state->__pyx_tuple__1118); + Py_VISIT(traverse_module_state->__pyx_tuple__1120); + Py_VISIT(traverse_module_state->__pyx_tuple__1122); + Py_VISIT(traverse_module_state->__pyx_tuple__1124); + Py_VISIT(traverse_module_state->__pyx_tuple__1126); + Py_VISIT(traverse_module_state->__pyx_tuple__1128); + Py_VISIT(traverse_module_state->__pyx_tuple__1131); + Py_VISIT(traverse_module_state->__pyx_tuple__1133); + Py_VISIT(traverse_module_state->__pyx_tuple__1137); + Py_VISIT(traverse_module_state->__pyx_tuple__1141); + Py_VISIT(traverse_module_state->__pyx_tuple__1143); + Py_VISIT(traverse_module_state->__pyx_tuple__1144); + Py_VISIT(traverse_module_state->__pyx_tuple__1151); + Py_VISIT(traverse_module_state->__pyx_codeobj__128); + Py_VISIT(traverse_module_state->__pyx_codeobj__130); + Py_VISIT(traverse_module_state->__pyx_codeobj__133); + Py_VISIT(traverse_module_state->__pyx_codeobj__135); + Py_VISIT(traverse_module_state->__pyx_codeobj__137); + Py_VISIT(traverse_module_state->__pyx_codeobj__139); + Py_VISIT(traverse_module_state->__pyx_codeobj__140); + Py_VISIT(traverse_module_state->__pyx_codeobj__142); + Py_VISIT(traverse_module_state->__pyx_codeobj__144); + Py_VISIT(traverse_module_state->__pyx_codeobj__146); + Py_VISIT(traverse_module_state->__pyx_codeobj__148); + Py_VISIT(traverse_module_state->__pyx_codeobj__150); + Py_VISIT(traverse_module_state->__pyx_codeobj__152); + Py_VISIT(traverse_module_state->__pyx_codeobj__154); + Py_VISIT(traverse_module_state->__pyx_codeobj__156); + Py_VISIT(traverse_module_state->__pyx_codeobj__157); + Py_VISIT(traverse_module_state->__pyx_codeobj__158); + Py_VISIT(traverse_module_state->__pyx_codeobj__160); + Py_VISIT(traverse_module_state->__pyx_codeobj__161); + Py_VISIT(traverse_module_state->__pyx_codeobj__166); + Py_VISIT(traverse_module_state->__pyx_codeobj__167); + Py_VISIT(traverse_module_state->__pyx_codeobj__168); + Py_VISIT(traverse_module_state->__pyx_codeobj__169); + Py_VISIT(traverse_module_state->__pyx_codeobj__170); + Py_VISIT(traverse_module_state->__pyx_codeobj__171); + Py_VISIT(traverse_module_state->__pyx_codeobj__172); + Py_VISIT(traverse_module_state->__pyx_codeobj__173); + Py_VISIT(traverse_module_state->__pyx_codeobj__174); + Py_VISIT(traverse_module_state->__pyx_codeobj__175); + Py_VISIT(traverse_module_state->__pyx_codeobj__176); + Py_VISIT(traverse_module_state->__pyx_codeobj__177); + Py_VISIT(traverse_module_state->__pyx_codeobj__178); + Py_VISIT(traverse_module_state->__pyx_codeobj__179); + Py_VISIT(traverse_module_state->__pyx_codeobj__180); + Py_VISIT(traverse_module_state->__pyx_codeobj__181); + Py_VISIT(traverse_module_state->__pyx_codeobj__183); + Py_VISIT(traverse_module_state->__pyx_codeobj__184); + Py_VISIT(traverse_module_state->__pyx_codeobj__185); + Py_VISIT(traverse_module_state->__pyx_codeobj__186); + Py_VISIT(traverse_module_state->__pyx_codeobj__187); + Py_VISIT(traverse_module_state->__pyx_codeobj__189); + Py_VISIT(traverse_module_state->__pyx_codeobj__191); + Py_VISIT(traverse_module_state->__pyx_codeobj__193); + Py_VISIT(traverse_module_state->__pyx_codeobj__195); + Py_VISIT(traverse_module_state->__pyx_codeobj__196); + Py_VISIT(traverse_module_state->__pyx_codeobj__197); + Py_VISIT(traverse_module_state->__pyx_codeobj__199); + Py_VISIT(traverse_module_state->__pyx_codeobj__201); + Py_VISIT(traverse_module_state->__pyx_codeobj__204); + Py_VISIT(traverse_module_state->__pyx_codeobj__206); + Py_VISIT(traverse_module_state->__pyx_codeobj__208); + Py_VISIT(traverse_module_state->__pyx_codeobj__211); + Py_VISIT(traverse_module_state->__pyx_codeobj__214); + Py_VISIT(traverse_module_state->__pyx_codeobj__216); + Py_VISIT(traverse_module_state->__pyx_codeobj__219); + Py_VISIT(traverse_module_state->__pyx_codeobj__221); + Py_VISIT(traverse_module_state->__pyx_codeobj__223); + Py_VISIT(traverse_module_state->__pyx_codeobj__225); + Py_VISIT(traverse_module_state->__pyx_codeobj__227); + Py_VISIT(traverse_module_state->__pyx_codeobj__228); + Py_VISIT(traverse_module_state->__pyx_codeobj__230); + Py_VISIT(traverse_module_state->__pyx_codeobj__232); + Py_VISIT(traverse_module_state->__pyx_codeobj__234); + Py_VISIT(traverse_module_state->__pyx_codeobj__236); + Py_VISIT(traverse_module_state->__pyx_codeobj__237); + Py_VISIT(traverse_module_state->__pyx_codeobj__239); + Py_VISIT(traverse_module_state->__pyx_codeobj__240); + Py_VISIT(traverse_module_state->__pyx_codeobj__242); + Py_VISIT(traverse_module_state->__pyx_codeobj__244); + Py_VISIT(traverse_module_state->__pyx_codeobj__246); + Py_VISIT(traverse_module_state->__pyx_codeobj__248); + Py_VISIT(traverse_module_state->__pyx_codeobj__250); + Py_VISIT(traverse_module_state->__pyx_codeobj__251); + Py_VISIT(traverse_module_state->__pyx_codeobj__252); + Py_VISIT(traverse_module_state->__pyx_codeobj__253); + Py_VISIT(traverse_module_state->__pyx_codeobj__254); + Py_VISIT(traverse_module_state->__pyx_codeobj__255); + Py_VISIT(traverse_module_state->__pyx_codeobj__256); + Py_VISIT(traverse_module_state->__pyx_codeobj__257); + Py_VISIT(traverse_module_state->__pyx_codeobj__258); + Py_VISIT(traverse_module_state->__pyx_codeobj__259); + Py_VISIT(traverse_module_state->__pyx_codeobj__261); + Py_VISIT(traverse_module_state->__pyx_codeobj__263); + Py_VISIT(traverse_module_state->__pyx_codeobj__265); + Py_VISIT(traverse_module_state->__pyx_codeobj__267); + Py_VISIT(traverse_module_state->__pyx_codeobj__269); + Py_VISIT(traverse_module_state->__pyx_codeobj__270); + Py_VISIT(traverse_module_state->__pyx_codeobj__272); + Py_VISIT(traverse_module_state->__pyx_codeobj__273); + Py_VISIT(traverse_module_state->__pyx_codeobj__274); + Py_VISIT(traverse_module_state->__pyx_codeobj__275); + Py_VISIT(traverse_module_state->__pyx_codeobj__276); + Py_VISIT(traverse_module_state->__pyx_codeobj__277); + Py_VISIT(traverse_module_state->__pyx_codeobj__278); + Py_VISIT(traverse_module_state->__pyx_codeobj__279); + Py_VISIT(traverse_module_state->__pyx_codeobj__281); + Py_VISIT(traverse_module_state->__pyx_codeobj__282); + Py_VISIT(traverse_module_state->__pyx_codeobj__283); + Py_VISIT(traverse_module_state->__pyx_codeobj__284); + Py_VISIT(traverse_module_state->__pyx_codeobj__285); + Py_VISIT(traverse_module_state->__pyx_codeobj__286); + Py_VISIT(traverse_module_state->__pyx_codeobj__287); + Py_VISIT(traverse_module_state->__pyx_codeobj__288); + Py_VISIT(traverse_module_state->__pyx_codeobj__290); + Py_VISIT(traverse_module_state->__pyx_codeobj__291); + Py_VISIT(traverse_module_state->__pyx_codeobj__292); + Py_VISIT(traverse_module_state->__pyx_codeobj__293); + Py_VISIT(traverse_module_state->__pyx_codeobj__294); + Py_VISIT(traverse_module_state->__pyx_codeobj__295); + Py_VISIT(traverse_module_state->__pyx_codeobj__297); + Py_VISIT(traverse_module_state->__pyx_codeobj__298); + Py_VISIT(traverse_module_state->__pyx_codeobj__299); + Py_VISIT(traverse_module_state->__pyx_codeobj__300); + Py_VISIT(traverse_module_state->__pyx_codeobj__301); + Py_VISIT(traverse_module_state->__pyx_codeobj__303); + Py_VISIT(traverse_module_state->__pyx_codeobj__305); + Py_VISIT(traverse_module_state->__pyx_codeobj__307); + Py_VISIT(traverse_module_state->__pyx_codeobj__308); + Py_VISIT(traverse_module_state->__pyx_codeobj__310); + Py_VISIT(traverse_module_state->__pyx_codeobj__312); + Py_VISIT(traverse_module_state->__pyx_codeobj__314); + Py_VISIT(traverse_module_state->__pyx_codeobj__316); + Py_VISIT(traverse_module_state->__pyx_codeobj__318); + Py_VISIT(traverse_module_state->__pyx_codeobj__320); + Py_VISIT(traverse_module_state->__pyx_codeobj__322); + Py_VISIT(traverse_module_state->__pyx_codeobj__324); + Py_VISIT(traverse_module_state->__pyx_codeobj__325); + Py_VISIT(traverse_module_state->__pyx_codeobj__327); + Py_VISIT(traverse_module_state->__pyx_codeobj__328); + Py_VISIT(traverse_module_state->__pyx_codeobj__329); + Py_VISIT(traverse_module_state->__pyx_codeobj__330); + Py_VISIT(traverse_module_state->__pyx_codeobj__331); + Py_VISIT(traverse_module_state->__pyx_codeobj__332); + Py_VISIT(traverse_module_state->__pyx_codeobj__333); + Py_VISIT(traverse_module_state->__pyx_codeobj__334); + Py_VISIT(traverse_module_state->__pyx_codeobj__335); + Py_VISIT(traverse_module_state->__pyx_codeobj__336); + Py_VISIT(traverse_module_state->__pyx_codeobj__337); + Py_VISIT(traverse_module_state->__pyx_codeobj__338); + Py_VISIT(traverse_module_state->__pyx_codeobj__339); + Py_VISIT(traverse_module_state->__pyx_codeobj__340); + Py_VISIT(traverse_module_state->__pyx_codeobj__341); + Py_VISIT(traverse_module_state->__pyx_codeobj__342); + Py_VISIT(traverse_module_state->__pyx_codeobj__343); + Py_VISIT(traverse_module_state->__pyx_codeobj__344); + Py_VISIT(traverse_module_state->__pyx_codeobj__345); + Py_VISIT(traverse_module_state->__pyx_codeobj__346); + Py_VISIT(traverse_module_state->__pyx_codeobj__347); + Py_VISIT(traverse_module_state->__pyx_codeobj__349); + Py_VISIT(traverse_module_state->__pyx_codeobj__350); + Py_VISIT(traverse_module_state->__pyx_codeobj__351); + Py_VISIT(traverse_module_state->__pyx_codeobj__352); + Py_VISIT(traverse_module_state->__pyx_codeobj__353); + Py_VISIT(traverse_module_state->__pyx_codeobj__354); + Py_VISIT(traverse_module_state->__pyx_codeobj__355); + Py_VISIT(traverse_module_state->__pyx_codeobj__356); + Py_VISIT(traverse_module_state->__pyx_codeobj__357); + Py_VISIT(traverse_module_state->__pyx_codeobj__358); + Py_VISIT(traverse_module_state->__pyx_codeobj__360); + Py_VISIT(traverse_module_state->__pyx_codeobj__361); + Py_VISIT(traverse_module_state->__pyx_codeobj__362); + Py_VISIT(traverse_module_state->__pyx_codeobj__363); + Py_VISIT(traverse_module_state->__pyx_codeobj__364); + Py_VISIT(traverse_module_state->__pyx_codeobj__365); + Py_VISIT(traverse_module_state->__pyx_codeobj__366); + Py_VISIT(traverse_module_state->__pyx_codeobj__367); + Py_VISIT(traverse_module_state->__pyx_codeobj__369); + Py_VISIT(traverse_module_state->__pyx_codeobj__370); + Py_VISIT(traverse_module_state->__pyx_codeobj__371); + Py_VISIT(traverse_module_state->__pyx_codeobj__372); + Py_VISIT(traverse_module_state->__pyx_codeobj__373); + Py_VISIT(traverse_module_state->__pyx_codeobj__374); + Py_VISIT(traverse_module_state->__pyx_codeobj__375); + Py_VISIT(traverse_module_state->__pyx_codeobj__376); + Py_VISIT(traverse_module_state->__pyx_codeobj__378); + Py_VISIT(traverse_module_state->__pyx_codeobj__379); + Py_VISIT(traverse_module_state->__pyx_codeobj__380); + Py_VISIT(traverse_module_state->__pyx_codeobj__381); + Py_VISIT(traverse_module_state->__pyx_codeobj__382); + Py_VISIT(traverse_module_state->__pyx_codeobj__383); + Py_VISIT(traverse_module_state->__pyx_codeobj__384); + Py_VISIT(traverse_module_state->__pyx_codeobj__385); + Py_VISIT(traverse_module_state->__pyx_codeobj__386); + Py_VISIT(traverse_module_state->__pyx_codeobj__387); + Py_VISIT(traverse_module_state->__pyx_codeobj__388); + Py_VISIT(traverse_module_state->__pyx_codeobj__389); + Py_VISIT(traverse_module_state->__pyx_codeobj__390); + Py_VISIT(traverse_module_state->__pyx_codeobj__391); + Py_VISIT(traverse_module_state->__pyx_codeobj__392); + Py_VISIT(traverse_module_state->__pyx_codeobj__393); + Py_VISIT(traverse_module_state->__pyx_codeobj__395); + Py_VISIT(traverse_module_state->__pyx_codeobj__396); + Py_VISIT(traverse_module_state->__pyx_codeobj__397); + Py_VISIT(traverse_module_state->__pyx_codeobj__399); + Py_VISIT(traverse_module_state->__pyx_codeobj__401); + Py_VISIT(traverse_module_state->__pyx_codeobj__403); + Py_VISIT(traverse_module_state->__pyx_codeobj__404); + Py_VISIT(traverse_module_state->__pyx_codeobj__405); + Py_VISIT(traverse_module_state->__pyx_codeobj__406); + Py_VISIT(traverse_module_state->__pyx_codeobj__407); + Py_VISIT(traverse_module_state->__pyx_codeobj__408); + Py_VISIT(traverse_module_state->__pyx_codeobj__409); + Py_VISIT(traverse_module_state->__pyx_codeobj__410); + Py_VISIT(traverse_module_state->__pyx_codeobj__411); + Py_VISIT(traverse_module_state->__pyx_codeobj__413); + Py_VISIT(traverse_module_state->__pyx_codeobj__414); + Py_VISIT(traverse_module_state->__pyx_codeobj__415); + Py_VISIT(traverse_module_state->__pyx_codeobj__416); + Py_VISIT(traverse_module_state->__pyx_codeobj__417); + Py_VISIT(traverse_module_state->__pyx_codeobj__419); + Py_VISIT(traverse_module_state->__pyx_codeobj__420); + Py_VISIT(traverse_module_state->__pyx_codeobj__421); + Py_VISIT(traverse_module_state->__pyx_codeobj__422); + Py_VISIT(traverse_module_state->__pyx_codeobj__423); + Py_VISIT(traverse_module_state->__pyx_codeobj__424); + Py_VISIT(traverse_module_state->__pyx_codeobj__425); + Py_VISIT(traverse_module_state->__pyx_codeobj__426); + Py_VISIT(traverse_module_state->__pyx_codeobj__427); + Py_VISIT(traverse_module_state->__pyx_codeobj__428); + Py_VISIT(traverse_module_state->__pyx_codeobj__429); + Py_VISIT(traverse_module_state->__pyx_codeobj__430); + Py_VISIT(traverse_module_state->__pyx_codeobj__431); + Py_VISIT(traverse_module_state->__pyx_codeobj__432); + Py_VISIT(traverse_module_state->__pyx_codeobj__433); + Py_VISIT(traverse_module_state->__pyx_codeobj__434); + Py_VISIT(traverse_module_state->__pyx_codeobj__435); + Py_VISIT(traverse_module_state->__pyx_codeobj__437); + Py_VISIT(traverse_module_state->__pyx_codeobj__438); + Py_VISIT(traverse_module_state->__pyx_codeobj__439); + Py_VISIT(traverse_module_state->__pyx_codeobj__443); + Py_VISIT(traverse_module_state->__pyx_codeobj__444); + Py_VISIT(traverse_module_state->__pyx_codeobj__445); + Py_VISIT(traverse_module_state->__pyx_codeobj__446); + Py_VISIT(traverse_module_state->__pyx_codeobj__447); + Py_VISIT(traverse_module_state->__pyx_codeobj__448); + Py_VISIT(traverse_module_state->__pyx_codeobj__449); + Py_VISIT(traverse_module_state->__pyx_codeobj__450); + Py_VISIT(traverse_module_state->__pyx_codeobj__451); + Py_VISIT(traverse_module_state->__pyx_codeobj__452); + Py_VISIT(traverse_module_state->__pyx_codeobj__453); + Py_VISIT(traverse_module_state->__pyx_codeobj__454); + Py_VISIT(traverse_module_state->__pyx_codeobj__455); + Py_VISIT(traverse_module_state->__pyx_codeobj__456); + Py_VISIT(traverse_module_state->__pyx_codeobj__457); + Py_VISIT(traverse_module_state->__pyx_codeobj__458); + Py_VISIT(traverse_module_state->__pyx_codeobj__459); + Py_VISIT(traverse_module_state->__pyx_codeobj__460); + Py_VISIT(traverse_module_state->__pyx_codeobj__461); + Py_VISIT(traverse_module_state->__pyx_codeobj__462); + Py_VISIT(traverse_module_state->__pyx_codeobj__463); + Py_VISIT(traverse_module_state->__pyx_codeobj__464); + Py_VISIT(traverse_module_state->__pyx_codeobj__465); + Py_VISIT(traverse_module_state->__pyx_codeobj__466); + Py_VISIT(traverse_module_state->__pyx_codeobj__467); + Py_VISIT(traverse_module_state->__pyx_codeobj__468); + Py_VISIT(traverse_module_state->__pyx_codeobj__469); + Py_VISIT(traverse_module_state->__pyx_codeobj__470); + Py_VISIT(traverse_module_state->__pyx_codeobj__472); + Py_VISIT(traverse_module_state->__pyx_codeobj__473); + Py_VISIT(traverse_module_state->__pyx_codeobj__474); + Py_VISIT(traverse_module_state->__pyx_codeobj__476); + Py_VISIT(traverse_module_state->__pyx_codeobj__477); + Py_VISIT(traverse_module_state->__pyx_codeobj__478); + Py_VISIT(traverse_module_state->__pyx_codeobj__480); + Py_VISIT(traverse_module_state->__pyx_codeobj__482); + Py_VISIT(traverse_module_state->__pyx_codeobj__484); + Py_VISIT(traverse_module_state->__pyx_codeobj__485); + Py_VISIT(traverse_module_state->__pyx_codeobj__486); + Py_VISIT(traverse_module_state->__pyx_codeobj__487); + Py_VISIT(traverse_module_state->__pyx_codeobj__489); + Py_VISIT(traverse_module_state->__pyx_codeobj__490); + Py_VISIT(traverse_module_state->__pyx_codeobj__491); + Py_VISIT(traverse_module_state->__pyx_codeobj__492); + Py_VISIT(traverse_module_state->__pyx_codeobj__493); + Py_VISIT(traverse_module_state->__pyx_codeobj__494); + Py_VISIT(traverse_module_state->__pyx_codeobj__495); + Py_VISIT(traverse_module_state->__pyx_codeobj__496); + Py_VISIT(traverse_module_state->__pyx_codeobj__497); + Py_VISIT(traverse_module_state->__pyx_codeobj__498); + Py_VISIT(traverse_module_state->__pyx_codeobj__499); + Py_VISIT(traverse_module_state->__pyx_codeobj__500); + Py_VISIT(traverse_module_state->__pyx_codeobj__501); + Py_VISIT(traverse_module_state->__pyx_codeobj__502); + Py_VISIT(traverse_module_state->__pyx_codeobj__503); + Py_VISIT(traverse_module_state->__pyx_codeobj__504); + Py_VISIT(traverse_module_state->__pyx_codeobj__505); + Py_VISIT(traverse_module_state->__pyx_codeobj__506); + Py_VISIT(traverse_module_state->__pyx_codeobj__507); + Py_VISIT(traverse_module_state->__pyx_codeobj__508); + Py_VISIT(traverse_module_state->__pyx_codeobj__510); + Py_VISIT(traverse_module_state->__pyx_codeobj__511); + Py_VISIT(traverse_module_state->__pyx_codeobj__512); + Py_VISIT(traverse_module_state->__pyx_codeobj__514); + Py_VISIT(traverse_module_state->__pyx_codeobj__516); + Py_VISIT(traverse_module_state->__pyx_codeobj__517); + Py_VISIT(traverse_module_state->__pyx_codeobj__518); + Py_VISIT(traverse_module_state->__pyx_codeobj__519); + Py_VISIT(traverse_module_state->__pyx_codeobj__520); + Py_VISIT(traverse_module_state->__pyx_codeobj__522); + Py_VISIT(traverse_module_state->__pyx_codeobj__523); + Py_VISIT(traverse_module_state->__pyx_codeobj__524); + Py_VISIT(traverse_module_state->__pyx_codeobj__525); + Py_VISIT(traverse_module_state->__pyx_codeobj__526); + Py_VISIT(traverse_module_state->__pyx_codeobj__527); + Py_VISIT(traverse_module_state->__pyx_codeobj__529); + Py_VISIT(traverse_module_state->__pyx_codeobj__531); + Py_VISIT(traverse_module_state->__pyx_codeobj__532); + Py_VISIT(traverse_module_state->__pyx_codeobj__533); + Py_VISIT(traverse_module_state->__pyx_codeobj__534); + Py_VISIT(traverse_module_state->__pyx_codeobj__535); + Py_VISIT(traverse_module_state->__pyx_codeobj__536); + Py_VISIT(traverse_module_state->__pyx_codeobj__537); + Py_VISIT(traverse_module_state->__pyx_codeobj__538); + Py_VISIT(traverse_module_state->__pyx_codeobj__539); + Py_VISIT(traverse_module_state->__pyx_codeobj__540); + Py_VISIT(traverse_module_state->__pyx_codeobj__542); + Py_VISIT(traverse_module_state->__pyx_codeobj__543); + Py_VISIT(traverse_module_state->__pyx_codeobj__544); + Py_VISIT(traverse_module_state->__pyx_codeobj__545); + Py_VISIT(traverse_module_state->__pyx_codeobj__546); + Py_VISIT(traverse_module_state->__pyx_codeobj__547); + Py_VISIT(traverse_module_state->__pyx_codeobj__548); + Py_VISIT(traverse_module_state->__pyx_codeobj__549); + Py_VISIT(traverse_module_state->__pyx_codeobj__550); + Py_VISIT(traverse_module_state->__pyx_codeobj__552); + Py_VISIT(traverse_module_state->__pyx_codeobj__553); + Py_VISIT(traverse_module_state->__pyx_codeobj__554); + Py_VISIT(traverse_module_state->__pyx_codeobj__555); + Py_VISIT(traverse_module_state->__pyx_codeobj__557); + Py_VISIT(traverse_module_state->__pyx_codeobj__559); + Py_VISIT(traverse_module_state->__pyx_codeobj__561); + Py_VISIT(traverse_module_state->__pyx_codeobj__563); + Py_VISIT(traverse_module_state->__pyx_codeobj__564); + Py_VISIT(traverse_module_state->__pyx_codeobj__565); + Py_VISIT(traverse_module_state->__pyx_codeobj__566); + Py_VISIT(traverse_module_state->__pyx_codeobj__568); + Py_VISIT(traverse_module_state->__pyx_codeobj__569); + Py_VISIT(traverse_module_state->__pyx_codeobj__570); + Py_VISIT(traverse_module_state->__pyx_codeobj__571); + Py_VISIT(traverse_module_state->__pyx_codeobj__573); + Py_VISIT(traverse_module_state->__pyx_codeobj__574); + Py_VISIT(traverse_module_state->__pyx_codeobj__575); + Py_VISIT(traverse_module_state->__pyx_codeobj__576); + Py_VISIT(traverse_module_state->__pyx_codeobj__577); + Py_VISIT(traverse_module_state->__pyx_codeobj__578); + Py_VISIT(traverse_module_state->__pyx_codeobj__579); + Py_VISIT(traverse_module_state->__pyx_codeobj__580); + Py_VISIT(traverse_module_state->__pyx_codeobj__581); + Py_VISIT(traverse_module_state->__pyx_codeobj__582); + Py_VISIT(traverse_module_state->__pyx_codeobj__583); + Py_VISIT(traverse_module_state->__pyx_codeobj__584); + Py_VISIT(traverse_module_state->__pyx_codeobj__585); + Py_VISIT(traverse_module_state->__pyx_codeobj__586); + Py_VISIT(traverse_module_state->__pyx_codeobj__587); + Py_VISIT(traverse_module_state->__pyx_codeobj__588); + Py_VISIT(traverse_module_state->__pyx_codeobj__589); + Py_VISIT(traverse_module_state->__pyx_codeobj__590); + Py_VISIT(traverse_module_state->__pyx_codeobj__591); + Py_VISIT(traverse_module_state->__pyx_codeobj__592); + Py_VISIT(traverse_module_state->__pyx_codeobj__593); + Py_VISIT(traverse_module_state->__pyx_codeobj__594); + Py_VISIT(traverse_module_state->__pyx_codeobj__595); + Py_VISIT(traverse_module_state->__pyx_codeobj__597); + Py_VISIT(traverse_module_state->__pyx_codeobj__598); + Py_VISIT(traverse_module_state->__pyx_codeobj__599); + Py_VISIT(traverse_module_state->__pyx_codeobj__600); + Py_VISIT(traverse_module_state->__pyx_codeobj__601); + Py_VISIT(traverse_module_state->__pyx_codeobj__603); + Py_VISIT(traverse_module_state->__pyx_codeobj__605); + Py_VISIT(traverse_module_state->__pyx_codeobj__606); + Py_VISIT(traverse_module_state->__pyx_codeobj__608); + Py_VISIT(traverse_module_state->__pyx_codeobj__610); + Py_VISIT(traverse_module_state->__pyx_codeobj__612); + Py_VISIT(traverse_module_state->__pyx_codeobj__613); + Py_VISIT(traverse_module_state->__pyx_codeobj__615); + Py_VISIT(traverse_module_state->__pyx_codeobj__616); + Py_VISIT(traverse_module_state->__pyx_codeobj__617); + Py_VISIT(traverse_module_state->__pyx_codeobj__618); + Py_VISIT(traverse_module_state->__pyx_codeobj__619); + Py_VISIT(traverse_module_state->__pyx_codeobj__620); + Py_VISIT(traverse_module_state->__pyx_codeobj__621); + Py_VISIT(traverse_module_state->__pyx_codeobj__622); + Py_VISIT(traverse_module_state->__pyx_codeobj__623); + Py_VISIT(traverse_module_state->__pyx_codeobj__624); + Py_VISIT(traverse_module_state->__pyx_codeobj__625); + Py_VISIT(traverse_module_state->__pyx_codeobj__626); + Py_VISIT(traverse_module_state->__pyx_codeobj__627); + Py_VISIT(traverse_module_state->__pyx_codeobj__628); + Py_VISIT(traverse_module_state->__pyx_codeobj__629); + Py_VISIT(traverse_module_state->__pyx_codeobj__630); + Py_VISIT(traverse_module_state->__pyx_codeobj__631); + Py_VISIT(traverse_module_state->__pyx_codeobj__632); + Py_VISIT(traverse_module_state->__pyx_codeobj__633); + Py_VISIT(traverse_module_state->__pyx_codeobj__634); + Py_VISIT(traverse_module_state->__pyx_codeobj__635); + Py_VISIT(traverse_module_state->__pyx_codeobj__637); + Py_VISIT(traverse_module_state->__pyx_codeobj__638); + Py_VISIT(traverse_module_state->__pyx_codeobj__639); + Py_VISIT(traverse_module_state->__pyx_codeobj__640); + Py_VISIT(traverse_module_state->__pyx_codeobj__641); + Py_VISIT(traverse_module_state->__pyx_codeobj__642); + Py_VISIT(traverse_module_state->__pyx_codeobj__643); + Py_VISIT(traverse_module_state->__pyx_codeobj__645); + Py_VISIT(traverse_module_state->__pyx_codeobj__646); + Py_VISIT(traverse_module_state->__pyx_codeobj__647); + Py_VISIT(traverse_module_state->__pyx_codeobj__648); + Py_VISIT(traverse_module_state->__pyx_codeobj__649); + Py_VISIT(traverse_module_state->__pyx_codeobj__650); + Py_VISIT(traverse_module_state->__pyx_codeobj__652); + Py_VISIT(traverse_module_state->__pyx_codeobj__655); + Py_VISIT(traverse_module_state->__pyx_codeobj__657); + Py_VISIT(traverse_module_state->__pyx_codeobj__658); + Py_VISIT(traverse_module_state->__pyx_codeobj__659); + Py_VISIT(traverse_module_state->__pyx_codeobj__661); + Py_VISIT(traverse_module_state->__pyx_codeobj__662); + Py_VISIT(traverse_module_state->__pyx_codeobj__664); + Py_VISIT(traverse_module_state->__pyx_codeobj__667); + Py_VISIT(traverse_module_state->__pyx_codeobj__669); + Py_VISIT(traverse_module_state->__pyx_codeobj__671); + Py_VISIT(traverse_module_state->__pyx_codeobj__672); + Py_VISIT(traverse_module_state->__pyx_codeobj__673); + Py_VISIT(traverse_module_state->__pyx_codeobj__675); + Py_VISIT(traverse_module_state->__pyx_codeobj__677); + Py_VISIT(traverse_module_state->__pyx_codeobj__678); + Py_VISIT(traverse_module_state->__pyx_codeobj__679); + Py_VISIT(traverse_module_state->__pyx_codeobj__681); + Py_VISIT(traverse_module_state->__pyx_codeobj__683); + Py_VISIT(traverse_module_state->__pyx_codeobj__686); + Py_VISIT(traverse_module_state->__pyx_codeobj__689); + Py_VISIT(traverse_module_state->__pyx_codeobj__691); + Py_VISIT(traverse_module_state->__pyx_codeobj__693); + Py_VISIT(traverse_module_state->__pyx_codeobj__695); + Py_VISIT(traverse_module_state->__pyx_codeobj__697); + Py_VISIT(traverse_module_state->__pyx_codeobj__699); + Py_VISIT(traverse_module_state->__pyx_codeobj__700); + Py_VISIT(traverse_module_state->__pyx_codeobj__701); + Py_VISIT(traverse_module_state->__pyx_codeobj__703); + Py_VISIT(traverse_module_state->__pyx_codeobj__705); + Py_VISIT(traverse_module_state->__pyx_codeobj__706); + Py_VISIT(traverse_module_state->__pyx_codeobj__707); + Py_VISIT(traverse_module_state->__pyx_codeobj__709); + Py_VISIT(traverse_module_state->__pyx_codeobj__711); + Py_VISIT(traverse_module_state->__pyx_codeobj__713); + Py_VISIT(traverse_module_state->__pyx_codeobj__715); + Py_VISIT(traverse_module_state->__pyx_codeobj__717); + Py_VISIT(traverse_module_state->__pyx_codeobj__718); + Py_VISIT(traverse_module_state->__pyx_codeobj__719); + Py_VISIT(traverse_module_state->__pyx_codeobj__721); + Py_VISIT(traverse_module_state->__pyx_codeobj__723); + Py_VISIT(traverse_module_state->__pyx_codeobj__724); + Py_VISIT(traverse_module_state->__pyx_codeobj__725); + Py_VISIT(traverse_module_state->__pyx_codeobj__726); + Py_VISIT(traverse_module_state->__pyx_codeobj__727); + Py_VISIT(traverse_module_state->__pyx_codeobj__728); + Py_VISIT(traverse_module_state->__pyx_codeobj__729); + Py_VISIT(traverse_module_state->__pyx_codeobj__731); + Py_VISIT(traverse_module_state->__pyx_codeobj__732); + Py_VISIT(traverse_module_state->__pyx_codeobj__733); + Py_VISIT(traverse_module_state->__pyx_codeobj__735); + Py_VISIT(traverse_module_state->__pyx_codeobj__736); + Py_VISIT(traverse_module_state->__pyx_codeobj__738); + Py_VISIT(traverse_module_state->__pyx_codeobj__740); + Py_VISIT(traverse_module_state->__pyx_codeobj__741); + Py_VISIT(traverse_module_state->__pyx_codeobj__742); + Py_VISIT(traverse_module_state->__pyx_codeobj__744); + Py_VISIT(traverse_module_state->__pyx_codeobj__746); + Py_VISIT(traverse_module_state->__pyx_codeobj__748); + Py_VISIT(traverse_module_state->__pyx_codeobj__749); + Py_VISIT(traverse_module_state->__pyx_codeobj__751); + Py_VISIT(traverse_module_state->__pyx_codeobj__754); + Py_VISIT(traverse_module_state->__pyx_codeobj__755); + Py_VISIT(traverse_module_state->__pyx_codeobj__756); + Py_VISIT(traverse_module_state->__pyx_codeobj__757); + Py_VISIT(traverse_module_state->__pyx_codeobj__758); + Py_VISIT(traverse_module_state->__pyx_codeobj__759); + Py_VISIT(traverse_module_state->__pyx_codeobj__761); + Py_VISIT(traverse_module_state->__pyx_codeobj__762); + Py_VISIT(traverse_module_state->__pyx_codeobj__763); + Py_VISIT(traverse_module_state->__pyx_codeobj__764); + Py_VISIT(traverse_module_state->__pyx_codeobj__766); + Py_VISIT(traverse_module_state->__pyx_codeobj__768); + Py_VISIT(traverse_module_state->__pyx_codeobj__769); + Py_VISIT(traverse_module_state->__pyx_codeobj__771); + Py_VISIT(traverse_module_state->__pyx_codeobj__773); + Py_VISIT(traverse_module_state->__pyx_codeobj__774); + Py_VISIT(traverse_module_state->__pyx_codeobj__776); + Py_VISIT(traverse_module_state->__pyx_codeobj__777); + Py_VISIT(traverse_module_state->__pyx_codeobj__778); + Py_VISIT(traverse_module_state->__pyx_codeobj__779); + Py_VISIT(traverse_module_state->__pyx_codeobj__781); + Py_VISIT(traverse_module_state->__pyx_codeobj__784); + Py_VISIT(traverse_module_state->__pyx_codeobj__786); + Py_VISIT(traverse_module_state->__pyx_codeobj__788); + Py_VISIT(traverse_module_state->__pyx_codeobj__790); + Py_VISIT(traverse_module_state->__pyx_codeobj__792); + Py_VISIT(traverse_module_state->__pyx_codeobj__795); + Py_VISIT(traverse_module_state->__pyx_codeobj__797); + Py_VISIT(traverse_module_state->__pyx_codeobj__799); + Py_VISIT(traverse_module_state->__pyx_codeobj__802); + Py_VISIT(traverse_module_state->__pyx_codeobj__804); + Py_VISIT(traverse_module_state->__pyx_codeobj__806); + Py_VISIT(traverse_module_state->__pyx_codeobj__807); + Py_VISIT(traverse_module_state->__pyx_codeobj__809); + Py_VISIT(traverse_module_state->__pyx_codeobj__811); + Py_VISIT(traverse_module_state->__pyx_codeobj__813); + Py_VISIT(traverse_module_state->__pyx_codeobj__815); + Py_VISIT(traverse_module_state->__pyx_codeobj__817); + Py_VISIT(traverse_module_state->__pyx_codeobj__819); + Py_VISIT(traverse_module_state->__pyx_codeobj__822); + Py_VISIT(traverse_module_state->__pyx_codeobj__824); + Py_VISIT(traverse_module_state->__pyx_codeobj__827); + Py_VISIT(traverse_module_state->__pyx_codeobj__830); + Py_VISIT(traverse_module_state->__pyx_codeobj__833); + Py_VISIT(traverse_module_state->__pyx_codeobj__836); + Py_VISIT(traverse_module_state->__pyx_codeobj__838); + Py_VISIT(traverse_module_state->__pyx_codeobj__840); + Py_VISIT(traverse_module_state->__pyx_codeobj__841); + Py_VISIT(traverse_module_state->__pyx_codeobj__842); + Py_VISIT(traverse_module_state->__pyx_codeobj__843); + Py_VISIT(traverse_module_state->__pyx_codeobj__845); + Py_VISIT(traverse_module_state->__pyx_codeobj__847); + Py_VISIT(traverse_module_state->__pyx_codeobj__849); + Py_VISIT(traverse_module_state->__pyx_codeobj__851); + Py_VISIT(traverse_module_state->__pyx_codeobj__853); + Py_VISIT(traverse_module_state->__pyx_codeobj__855); + Py_VISIT(traverse_module_state->__pyx_codeobj__857); + Py_VISIT(traverse_module_state->__pyx_codeobj__858); + Py_VISIT(traverse_module_state->__pyx_codeobj__860); + Py_VISIT(traverse_module_state->__pyx_codeobj__861); + Py_VISIT(traverse_module_state->__pyx_codeobj__862); + Py_VISIT(traverse_module_state->__pyx_codeobj__864); + Py_VISIT(traverse_module_state->__pyx_codeobj__866); + Py_VISIT(traverse_module_state->__pyx_codeobj__868); + Py_VISIT(traverse_module_state->__pyx_codeobj__869); + Py_VISIT(traverse_module_state->__pyx_codeobj__870); + Py_VISIT(traverse_module_state->__pyx_codeobj__872); + Py_VISIT(traverse_module_state->__pyx_codeobj__874); + Py_VISIT(traverse_module_state->__pyx_codeobj__876); + Py_VISIT(traverse_module_state->__pyx_codeobj__878); + Py_VISIT(traverse_module_state->__pyx_codeobj__880); + Py_VISIT(traverse_module_state->__pyx_codeobj__882); + Py_VISIT(traverse_module_state->__pyx_codeobj__884); + Py_VISIT(traverse_module_state->__pyx_codeobj__886); + Py_VISIT(traverse_module_state->__pyx_codeobj__888); + Py_VISIT(traverse_module_state->__pyx_codeobj__889); + Py_VISIT(traverse_module_state->__pyx_codeobj__890); + Py_VISIT(traverse_module_state->__pyx_codeobj__891); + Py_VISIT(traverse_module_state->__pyx_codeobj__893); + Py_VISIT(traverse_module_state->__pyx_codeobj__895); + Py_VISIT(traverse_module_state->__pyx_codeobj__897); + Py_VISIT(traverse_module_state->__pyx_codeobj__898); + Py_VISIT(traverse_module_state->__pyx_codeobj__899); + Py_VISIT(traverse_module_state->__pyx_codeobj__901); + Py_VISIT(traverse_module_state->__pyx_codeobj__903); + Py_VISIT(traverse_module_state->__pyx_codeobj__904); + Py_VISIT(traverse_module_state->__pyx_codeobj__905); + Py_VISIT(traverse_module_state->__pyx_codeobj__906); + Py_VISIT(traverse_module_state->__pyx_codeobj__908); + Py_VISIT(traverse_module_state->__pyx_codeobj__910); + Py_VISIT(traverse_module_state->__pyx_codeobj__912); + Py_VISIT(traverse_module_state->__pyx_codeobj__914); + Py_VISIT(traverse_module_state->__pyx_codeobj__916); + Py_VISIT(traverse_module_state->__pyx_codeobj__918); + Py_VISIT(traverse_module_state->__pyx_codeobj__920); + Py_VISIT(traverse_module_state->__pyx_codeobj__922); + Py_VISIT(traverse_module_state->__pyx_codeobj__924); + Py_VISIT(traverse_module_state->__pyx_codeobj__926); + Py_VISIT(traverse_module_state->__pyx_codeobj__928); + Py_VISIT(traverse_module_state->__pyx_codeobj__931); + Py_VISIT(traverse_module_state->__pyx_codeobj__933); + Py_VISIT(traverse_module_state->__pyx_codeobj__935); + Py_VISIT(traverse_module_state->__pyx_codeobj__937); + Py_VISIT(traverse_module_state->__pyx_codeobj__939); + Py_VISIT(traverse_module_state->__pyx_codeobj__942); + Py_VISIT(traverse_module_state->__pyx_codeobj__944); + Py_VISIT(traverse_module_state->__pyx_codeobj__947); + Py_VISIT(traverse_module_state->__pyx_codeobj__949); + Py_VISIT(traverse_module_state->__pyx_codeobj__952); + Py_VISIT(traverse_module_state->__pyx_codeobj__954); + Py_VISIT(traverse_module_state->__pyx_codeobj__956); + Py_VISIT(traverse_module_state->__pyx_codeobj__958); + Py_VISIT(traverse_module_state->__pyx_codeobj__961); + Py_VISIT(traverse_module_state->__pyx_codeobj__963); + Py_VISIT(traverse_module_state->__pyx_codeobj__965); + Py_VISIT(traverse_module_state->__pyx_codeobj__967); + Py_VISIT(traverse_module_state->__pyx_codeobj__970); + Py_VISIT(traverse_module_state->__pyx_codeobj__972); + Py_VISIT(traverse_module_state->__pyx_codeobj__974); + Py_VISIT(traverse_module_state->__pyx_codeobj__976); + Py_VISIT(traverse_module_state->__pyx_codeobj__978); + Py_VISIT(traverse_module_state->__pyx_codeobj__980); + Py_VISIT(traverse_module_state->__pyx_codeobj__982); + Py_VISIT(traverse_module_state->__pyx_codeobj__984); + Py_VISIT(traverse_module_state->__pyx_codeobj__985); + Py_VISIT(traverse_module_state->__pyx_codeobj__986); + Py_VISIT(traverse_module_state->__pyx_codeobj__988); + Py_VISIT(traverse_module_state->__pyx_codeobj__990); + Py_VISIT(traverse_module_state->__pyx_codeobj__991); + Py_VISIT(traverse_module_state->__pyx_codeobj__992); + Py_VISIT(traverse_module_state->__pyx_codeobj__993); + Py_VISIT(traverse_module_state->__pyx_codeobj__995); + Py_VISIT(traverse_module_state->__pyx_codeobj__997); + Py_VISIT(traverse_module_state->__pyx_codeobj__998); + Py_VISIT(traverse_module_state->__pyx_codeobj__1000); + Py_VISIT(traverse_module_state->__pyx_codeobj__1002); + Py_VISIT(traverse_module_state->__pyx_codeobj__1003); + Py_VISIT(traverse_module_state->__pyx_codeobj__1004); + Py_VISIT(traverse_module_state->__pyx_codeobj__1005); + Py_VISIT(traverse_module_state->__pyx_codeobj__1007); + Py_VISIT(traverse_module_state->__pyx_codeobj__1008); + Py_VISIT(traverse_module_state->__pyx_codeobj__1009); + Py_VISIT(traverse_module_state->__pyx_codeobj__1010); + Py_VISIT(traverse_module_state->__pyx_codeobj__1011); + Py_VISIT(traverse_module_state->__pyx_codeobj__1013); + Py_VISIT(traverse_module_state->__pyx_codeobj__1014); + Py_VISIT(traverse_module_state->__pyx_codeobj__1015); + Py_VISIT(traverse_module_state->__pyx_codeobj__1016); + Py_VISIT(traverse_module_state->__pyx_codeobj__1017); + Py_VISIT(traverse_module_state->__pyx_codeobj__1019); + Py_VISIT(traverse_module_state->__pyx_codeobj__1020); + Py_VISIT(traverse_module_state->__pyx_codeobj__1021); + Py_VISIT(traverse_module_state->__pyx_codeobj__1023); + Py_VISIT(traverse_module_state->__pyx_codeobj__1026); + Py_VISIT(traverse_module_state->__pyx_codeobj__1028); + Py_VISIT(traverse_module_state->__pyx_codeobj__1029); + Py_VISIT(traverse_module_state->__pyx_codeobj__1031); + Py_VISIT(traverse_module_state->__pyx_codeobj__1033); + Py_VISIT(traverse_module_state->__pyx_codeobj__1036); + Py_VISIT(traverse_module_state->__pyx_codeobj__1038); + Py_VISIT(traverse_module_state->__pyx_codeobj__1041); + Py_VISIT(traverse_module_state->__pyx_codeobj__1042); + Py_VISIT(traverse_module_state->__pyx_codeobj__1043); + Py_VISIT(traverse_module_state->__pyx_codeobj__1045); + Py_VISIT(traverse_module_state->__pyx_codeobj__1047); + Py_VISIT(traverse_module_state->__pyx_codeobj__1049); + Py_VISIT(traverse_module_state->__pyx_codeobj__1052); + Py_VISIT(traverse_module_state->__pyx_codeobj__1055); + Py_VISIT(traverse_module_state->__pyx_codeobj__1056); + Py_VISIT(traverse_module_state->__pyx_codeobj__1057); + Py_VISIT(traverse_module_state->__pyx_codeobj__1058); + Py_VISIT(traverse_module_state->__pyx_codeobj__1059); + Py_VISIT(traverse_module_state->__pyx_codeobj__1060); + Py_VISIT(traverse_module_state->__pyx_codeobj__1062); + Py_VISIT(traverse_module_state->__pyx_codeobj__1063); + Py_VISIT(traverse_module_state->__pyx_codeobj__1065); + Py_VISIT(traverse_module_state->__pyx_codeobj__1067); + Py_VISIT(traverse_module_state->__pyx_codeobj__1068); + Py_VISIT(traverse_module_state->__pyx_codeobj__1070); + Py_VISIT(traverse_module_state->__pyx_codeobj__1072); + Py_VISIT(traverse_module_state->__pyx_codeobj__1073); + Py_VISIT(traverse_module_state->__pyx_codeobj__1074); + Py_VISIT(traverse_module_state->__pyx_codeobj__1076); + Py_VISIT(traverse_module_state->__pyx_codeobj__1077); + Py_VISIT(traverse_module_state->__pyx_codeobj__1078); + Py_VISIT(traverse_module_state->__pyx_codeobj__1079); + Py_VISIT(traverse_module_state->__pyx_codeobj__1081); + Py_VISIT(traverse_module_state->__pyx_codeobj__1082); + Py_VISIT(traverse_module_state->__pyx_codeobj__1083); + Py_VISIT(traverse_module_state->__pyx_codeobj__1084); + Py_VISIT(traverse_module_state->__pyx_codeobj__1085); + Py_VISIT(traverse_module_state->__pyx_codeobj__1087); + Py_VISIT(traverse_module_state->__pyx_codeobj__1089); + Py_VISIT(traverse_module_state->__pyx_codeobj__1090); + Py_VISIT(traverse_module_state->__pyx_codeobj__1092); + Py_VISIT(traverse_module_state->__pyx_codeobj__1093); + Py_VISIT(traverse_module_state->__pyx_codeobj__1095); + Py_VISIT(traverse_module_state->__pyx_codeobj__1096); + Py_VISIT(traverse_module_state->__pyx_codeobj__1097); + Py_VISIT(traverse_module_state->__pyx_codeobj__1099); + Py_VISIT(traverse_module_state->__pyx_codeobj__1101); + Py_VISIT(traverse_module_state->__pyx_codeobj__1103); + Py_VISIT(traverse_module_state->__pyx_codeobj__1105); + Py_VISIT(traverse_module_state->__pyx_codeobj__1107); + Py_VISIT(traverse_module_state->__pyx_codeobj__1109); + Py_VISIT(traverse_module_state->__pyx_codeobj__1110); + Py_VISIT(traverse_module_state->__pyx_codeobj__1111); + Py_VISIT(traverse_module_state->__pyx_codeobj__1112); + Py_VISIT(traverse_module_state->__pyx_codeobj__1113); + Py_VISIT(traverse_module_state->__pyx_codeobj__1115); + Py_VISIT(traverse_module_state->__pyx_codeobj__1117); + Py_VISIT(traverse_module_state->__pyx_codeobj__1119); + Py_VISIT(traverse_module_state->__pyx_codeobj__1121); + Py_VISIT(traverse_module_state->__pyx_codeobj__1123); + Py_VISIT(traverse_module_state->__pyx_codeobj__1125); + Py_VISIT(traverse_module_state->__pyx_codeobj__1127); + Py_VISIT(traverse_module_state->__pyx_codeobj__1129); + Py_VISIT(traverse_module_state->__pyx_codeobj__1130); + Py_VISIT(traverse_module_state->__pyx_codeobj__1132); + Py_VISIT(traverse_module_state->__pyx_codeobj__1134); + Py_VISIT(traverse_module_state->__pyx_codeobj__1135); + Py_VISIT(traverse_module_state->__pyx_codeobj__1136); + Py_VISIT(traverse_module_state->__pyx_codeobj__1138); + Py_VISIT(traverse_module_state->__pyx_codeobj__1139); + Py_VISIT(traverse_module_state->__pyx_codeobj__1140); + Py_VISIT(traverse_module_state->__pyx_codeobj__1142); + Py_VISIT(traverse_module_state->__pyx_codeobj__1145); + Py_VISIT(traverse_module_state->__pyx_codeobj__1146); + Py_VISIT(traverse_module_state->__pyx_codeobj__1147); + Py_VISIT(traverse_module_state->__pyx_codeobj__1148); + Py_VISIT(traverse_module_state->__pyx_codeobj__1149); + Py_VISIT(traverse_module_state->__pyx_codeobj__1150); + Py_VISIT(traverse_module_state->__pyx_codeobj__1152); + Py_VISIT(traverse_module_state->__pyx_codeobj__1153); + Py_VISIT(traverse_module_state->__pyx_codeobj__1154); + Py_VISIT(traverse_module_state->__pyx_codeobj__1155); + Py_VISIT(traverse_module_state->__pyx_codeobj__1156); + Py_VISIT(traverse_module_state->__pyx_codeobj__1157); + Py_VISIT(traverse_module_state->__pyx_codeobj__1158); + Py_VISIT(traverse_module_state->__pyx_codeobj__1159); + Py_VISIT(traverse_module_state->__pyx_codeobj__1160); + Py_VISIT(traverse_module_state->__pyx_codeobj__1161); + Py_VISIT(traverse_module_state->__pyx_codeobj__1162); + Py_VISIT(traverse_module_state->__pyx_codeobj__1163); + Py_VISIT(traverse_module_state->__pyx_codeobj__1164); + Py_VISIT(traverse_module_state->__pyx_codeobj__1165); + Py_VISIT(traverse_module_state->__pyx_codeobj__1166); + Py_VISIT(traverse_module_state->__pyx_codeobj__1167); + Py_VISIT(traverse_module_state->__pyx_codeobj__1168); + Py_VISIT(traverse_module_state->__pyx_codeobj__1169); + Py_VISIT(traverse_module_state->__pyx_codeobj__1170); + Py_VISIT(traverse_module_state->__pyx_codeobj__1171); + Py_VISIT(traverse_module_state->__pyx_codeobj__1172); + Py_VISIT(traverse_module_state->__pyx_codeobj__1173); + Py_VISIT(traverse_module_state->__pyx_codeobj__1174); + Py_VISIT(traverse_module_state->__pyx_codeobj__1175); + Py_VISIT(traverse_module_state->__pyx_codeobj__1176); + Py_VISIT(traverse_module_state->__pyx_codeobj__1177); + Py_VISIT(traverse_module_state->__pyx_codeobj__1178); + Py_VISIT(traverse_module_state->__pyx_codeobj__1179); + Py_VISIT(traverse_module_state->__pyx_codeobj__1180); + Py_VISIT(traverse_module_state->__pyx_codeobj__1181); + Py_VISIT(traverse_module_state->__pyx_codeobj__1182); + Py_VISIT(traverse_module_state->__pyx_codeobj__1183); + Py_VISIT(traverse_module_state->__pyx_codeobj__1184); + Py_VISIT(traverse_module_state->__pyx_codeobj__1185); + Py_VISIT(traverse_module_state->__pyx_codeobj__1186); + Py_VISIT(traverse_module_state->__pyx_codeobj__1187); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4type_type __pyx_mstate_global->__pyx_ptype_7cpython_4type_type +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_4bool_bool __pyx_mstate_global->__pyx_ptype_7cpython_4bool_bool +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#define __pyx_ptype_7cpython_7complex_complex __pyx_mstate_global->__pyx_ptype_7cpython_7complex_complex +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_9pyscipopt_4scip_Expr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Expr +#define __pyx_type_9pyscipopt_4scip_Event __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Event +#define __pyx_type_9pyscipopt_4scip_Column __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Column +#define __pyx_type_9pyscipopt_4scip_Row __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Row +#define __pyx_type_9pyscipopt_4scip_NLRow __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_NLRow +#define __pyx_type_9pyscipopt_4scip_Solution __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Solution +#define __pyx_type_9pyscipopt_4scip_DomainChanges __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_DomainChanges +#define __pyx_type_9pyscipopt_4scip_BoundChange __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_BoundChange +#define __pyx_type_9pyscipopt_4scip_Node __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Node +#define __pyx_type_9pyscipopt_4scip_Variable __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Variable +#define __pyx_type_9pyscipopt_4scip_Constraint __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Constraint +#define __pyx_type_9pyscipopt_4scip_Model __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Model +#define __pyx_type_9pyscipopt_4scip_ExprCons __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_ExprCons +#define __pyx_type_9pyscipopt_4scip_GenExpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_GenExpr +#define __pyx_type_9pyscipopt_4scip_SumExpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_SumExpr +#define __pyx_type_9pyscipopt_4scip_ProdExpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_ProdExpr +#define __pyx_type_9pyscipopt_4scip_VarExpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_VarExpr +#define __pyx_type_9pyscipopt_4scip_PowExpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PowExpr +#define __pyx_type_9pyscipopt_4scip_UnaryExpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_UnaryExpr +#define __pyx_type_9pyscipopt_4scip_Constant __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Constant +#define __pyx_type_9pyscipopt_4scip_LP __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_LP +#define __pyx_type_9pyscipopt_4scip_Benders __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Benders +#define __pyx_type_9pyscipopt_4scip_Benderscut __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Benderscut +#define __pyx_type_9pyscipopt_4scip_Branchrule __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Branchrule +#define __pyx_type_9pyscipopt_4scip_Conshdlr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Conshdlr +#define __pyx_type_9pyscipopt_4scip_Cutsel __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Cutsel +#define __pyx_type_9pyscipopt_4scip_Eventhdlr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Eventhdlr +#define __pyx_type_9pyscipopt_4scip_Heur __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Heur +#define __pyx_type_9pyscipopt_4scip_Presol __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Presol +#define __pyx_type_9pyscipopt_4scip_Pricer __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Pricer +#define __pyx_type_9pyscipopt_4scip_Prop __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Prop +#define __pyx_type_9pyscipopt_4scip_Sepa __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Sepa +#define __pyx_type_9pyscipopt_4scip_Reader __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Reader +#define __pyx_type_9pyscipopt_4scip_Relax __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Relax +#define __pyx_type_9pyscipopt_4scip_Nodesel __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_Nodesel +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE +#define __pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE __pyx_mstate_global->__pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE +#define __pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr +#define __pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr +#define __pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr +#define __pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr +#define __pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ __pyx_mstate_global->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ +#define __pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr __pyx_mstate_global->__pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr +#endif +#define __pyx_ptype_9pyscipopt_4scip_Expr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Expr +#define __pyx_ptype_9pyscipopt_4scip_Event __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Event +#define __pyx_ptype_9pyscipopt_4scip_Column __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Column +#define __pyx_ptype_9pyscipopt_4scip_Row __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Row +#define __pyx_ptype_9pyscipopt_4scip_NLRow __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_NLRow +#define __pyx_ptype_9pyscipopt_4scip_Solution __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Solution +#define __pyx_ptype_9pyscipopt_4scip_DomainChanges __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_DomainChanges +#define __pyx_ptype_9pyscipopt_4scip_BoundChange __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_BoundChange +#define __pyx_ptype_9pyscipopt_4scip_Node __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Node +#define __pyx_ptype_9pyscipopt_4scip_Variable __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Variable +#define __pyx_ptype_9pyscipopt_4scip_Constraint __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Constraint +#define __pyx_ptype_9pyscipopt_4scip_Model __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Model +#define __pyx_ptype_9pyscipopt_4scip_ExprCons __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_ExprCons +#define __pyx_ptype_9pyscipopt_4scip_GenExpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_GenExpr +#define __pyx_ptype_9pyscipopt_4scip_SumExpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_SumExpr +#define __pyx_ptype_9pyscipopt_4scip_ProdExpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_ProdExpr +#define __pyx_ptype_9pyscipopt_4scip_VarExpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_VarExpr +#define __pyx_ptype_9pyscipopt_4scip_PowExpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PowExpr +#define __pyx_ptype_9pyscipopt_4scip_UnaryExpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_UnaryExpr +#define __pyx_ptype_9pyscipopt_4scip_Constant __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Constant +#define __pyx_ptype_9pyscipopt_4scip_LP __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_LP +#define __pyx_ptype_9pyscipopt_4scip_Benders __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Benders +#define __pyx_ptype_9pyscipopt_4scip_Benderscut __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Benderscut +#define __pyx_ptype_9pyscipopt_4scip_Branchrule __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Branchrule +#define __pyx_ptype_9pyscipopt_4scip_Conshdlr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Conshdlr +#define __pyx_ptype_9pyscipopt_4scip_Cutsel __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Cutsel +#define __pyx_ptype_9pyscipopt_4scip_Eventhdlr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Eventhdlr +#define __pyx_ptype_9pyscipopt_4scip_Heur __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Heur +#define __pyx_ptype_9pyscipopt_4scip_Presol __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Presol +#define __pyx_ptype_9pyscipopt_4scip_Pricer __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Pricer +#define __pyx_ptype_9pyscipopt_4scip_Prop __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Prop +#define __pyx_ptype_9pyscipopt_4scip_Sepa __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Sepa +#define __pyx_ptype_9pyscipopt_4scip_Reader __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Reader +#define __pyx_ptype_9pyscipopt_4scip_Relax __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Relax +#define __pyx_ptype_9pyscipopt_4scip_Nodesel __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_Nodesel +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE +#define __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE +#define __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr +#define __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr +#define __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr +#define __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr +#define __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ +#define __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr __pyx_mstate_global->__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr +#define __pyx_n_s_AFTERLPLOOP __pyx_mstate_global->__pyx_n_s_AFTERLPLOOP +#define __pyx_n_s_AFTERLPNODE __pyx_mstate_global->__pyx_n_s_AFTERLPNODE +#define __pyx_n_s_AFTERLPPLUNGE __pyx_mstate_global->__pyx_n_s_AFTERLPPLUNGE +#define __pyx_n_s_AFTERPROPLOOP __pyx_mstate_global->__pyx_n_s_AFTERPROPLOOP +#define __pyx_n_s_AFTERPSEUDONODE __pyx_mstate_global->__pyx_n_s_AFTERPSEUDONODE +#define __pyx_n_s_AFTERPSEUDOPLUNGE __pyx_mstate_global->__pyx_n_s_AFTERPSEUDOPLUNGE +#define __pyx_n_s_AGGRESSIVE __pyx_mstate_global->__pyx_n_s_AGGRESSIVE +#define __pyx_n_u_ANDcons __pyx_mstate_global->__pyx_n_u_ANDcons +#define __pyx_n_s_AUTO __pyx_mstate_global->__pyx_n_s_AUTO +#define __pyx_n_s_AssertionError __pyx_mstate_global->__pyx_n_s_AssertionError +#define __pyx_n_u_B __pyx_mstate_global->__pyx_n_u_B +#define __pyx_n_s_BEFORELP __pyx_mstate_global->__pyx_n_s_BEFORELP +#define __pyx_n_s_BEFORENODE __pyx_mstate_global->__pyx_n_s_BEFORENODE +#define __pyx_n_s_BEFOREPRESOL __pyx_mstate_global->__pyx_n_s_BEFOREPRESOL +#define __pyx_n_s_BENCHMARK __pyx_mstate_global->__pyx_n_s_BENCHMARK +#define __pyx_n_s_BESTSOLFOUND __pyx_mstate_global->__pyx_n_s_BESTSOLFOUND +#define __pyx_n_s_BESTSOLLIMIT __pyx_mstate_global->__pyx_n_s_BESTSOLLIMIT +#define __pyx_n_u_BINARY __pyx_mstate_global->__pyx_n_u_BINARY +#define __pyx_n_s_BOUNDCHANGED __pyx_mstate_global->__pyx_n_s_BOUNDCHANGED +#define __pyx_n_s_BOUNDRELAXED __pyx_mstate_global->__pyx_n_s_BOUNDRELAXED +#define __pyx_n_s_BOUNDTIGHTENED __pyx_mstate_global->__pyx_n_s_BOUNDTIGHTENED +#define __pyx_n_s_BRANCHED __pyx_mstate_global->__pyx_n_s_BRANCHED +#define __pyx_n_s_Benders __pyx_mstate_global->__pyx_n_s_Benders +#define __pyx_n_s_Benders___reduce_cython __pyx_mstate_global->__pyx_n_s_Benders___reduce_cython +#define __pyx_n_s_Benders___setstate_cython __pyx_mstate_global->__pyx_n_s_Benders___setstate_cython +#define __pyx_n_s_Benders_benderscreatesub __pyx_mstate_global->__pyx_n_s_Benders_benderscreatesub +#define __pyx_n_s_Benders_bendersexit __pyx_mstate_global->__pyx_n_s_Benders_bendersexit +#define __pyx_n_s_Benders_bendersexitpre __pyx_mstate_global->__pyx_n_s_Benders_bendersexitpre +#define __pyx_n_s_Benders_bendersexitsol __pyx_mstate_global->__pyx_n_s_Benders_bendersexitsol +#define __pyx_n_s_Benders_bendersfree __pyx_mstate_global->__pyx_n_s_Benders_bendersfree +#define __pyx_n_s_Benders_bendersfreesub __pyx_mstate_global->__pyx_n_s_Benders_bendersfreesub +#define __pyx_n_s_Benders_bendersgetvar __pyx_mstate_global->__pyx_n_s_Benders_bendersgetvar +#define __pyx_n_s_Benders_bendersinit __pyx_mstate_global->__pyx_n_s_Benders_bendersinit +#define __pyx_n_s_Benders_bendersinitpre __pyx_mstate_global->__pyx_n_s_Benders_bendersinitpre +#define __pyx_n_s_Benders_bendersinitsol __pyx_mstate_global->__pyx_n_s_Benders_bendersinitsol +#define __pyx_n_s_Benders_benderspostsolve __pyx_mstate_global->__pyx_n_s_Benders_benderspostsolve +#define __pyx_n_s_Benders_benderspresubsolve __pyx_mstate_global->__pyx_n_s_Benders_benderspresubsolve +#define __pyx_n_s_Benders_benderssolvesub __pyx_mstate_global->__pyx_n_s_Benders_benderssolvesub +#define __pyx_n_s_Benders_benderssolvesubconvex __pyx_mstate_global->__pyx_n_s_Benders_benderssolvesubconvex +#define __pyx_n_s_Benderscut __pyx_mstate_global->__pyx_n_s_Benderscut +#define __pyx_n_s_Benderscut___reduce_cython __pyx_mstate_global->__pyx_n_s_Benderscut___reduce_cython +#define __pyx_n_s_Benderscut___setstate_cython __pyx_mstate_global->__pyx_n_s_Benderscut___setstate_cython +#define __pyx_n_s_Benderscut_benderscutexec __pyx_mstate_global->__pyx_n_s_Benderscut_benderscutexec +#define __pyx_n_s_Benderscut_benderscutexit __pyx_mstate_global->__pyx_n_s_Benderscut_benderscutexit +#define __pyx_n_s_Benderscut_benderscutexitsol __pyx_mstate_global->__pyx_n_s_Benderscut_benderscutexitsol +#define __pyx_n_s_Benderscut_benderscutfree __pyx_mstate_global->__pyx_n_s_Benderscut_benderscutfree +#define __pyx_n_s_Benderscut_benderscutinit __pyx_mstate_global->__pyx_n_s_Benderscut_benderscutinit +#define __pyx_n_s_Benderscut_benderscutinitsol __pyx_mstate_global->__pyx_n_s_Benderscut_benderscutinitsol +#define __pyx_n_s_BoundChange __pyx_mstate_global->__pyx_n_s_BoundChange +#define __pyx_n_s_BoundChange___reduce_cython __pyx_mstate_global->__pyx_n_s_BoundChange___reduce_cython +#define __pyx_n_s_BoundChange___setstate_cython __pyx_mstate_global->__pyx_n_s_BoundChange___setstate_cython +#define __pyx_n_s_BoundChange_getBoundchgtype __pyx_mstate_global->__pyx_n_s_BoundChange_getBoundchgtype +#define __pyx_n_s_BoundChange_getBoundtype __pyx_mstate_global->__pyx_n_s_BoundChange_getBoundtype +#define __pyx_n_s_BoundChange_getNewBound __pyx_mstate_global->__pyx_n_s_BoundChange_getNewBound +#define __pyx_n_s_BoundChange_getVar __pyx_mstate_global->__pyx_n_s_BoundChange_getVar +#define __pyx_n_s_BoundChange_isRedundant __pyx_mstate_global->__pyx_n_s_BoundChange_isRedundant +#define __pyx_n_s_Branchrule __pyx_mstate_global->__pyx_n_s_Branchrule +#define __pyx_n_s_Branchrule___reduce_cython __pyx_mstate_global->__pyx_n_s_Branchrule___reduce_cython +#define __pyx_n_s_Branchrule___setstate_cython __pyx_mstate_global->__pyx_n_s_Branchrule___setstate_cython +#define __pyx_n_s_Branchrule_branchexecext __pyx_mstate_global->__pyx_n_s_Branchrule_branchexecext +#define __pyx_n_s_Branchrule_branchexeclp __pyx_mstate_global->__pyx_n_s_Branchrule_branchexeclp +#define __pyx_n_s_Branchrule_branchexecps __pyx_mstate_global->__pyx_n_s_Branchrule_branchexecps +#define __pyx_n_s_Branchrule_branchexit __pyx_mstate_global->__pyx_n_s_Branchrule_branchexit +#define __pyx_n_s_Branchrule_branchexitsol __pyx_mstate_global->__pyx_n_s_Branchrule_branchexitsol +#define __pyx_n_s_Branchrule_branchfree __pyx_mstate_global->__pyx_n_s_Branchrule_branchfree +#define __pyx_n_s_Branchrule_branchinit __pyx_mstate_global->__pyx_n_s_Branchrule_branchinit +#define __pyx_n_s_Branchrule_branchinitsol __pyx_mstate_global->__pyx_n_s_Branchrule_branchinitsol +#define __pyx_n_u_C __pyx_mstate_global->__pyx_n_u_C +#define __pyx_n_s_CHECK __pyx_mstate_global->__pyx_n_s_CHECK +#define __pyx_n_s_CHILD __pyx_mstate_global->__pyx_n_s_CHILD +#define __pyx_n_s_CONS __pyx_mstate_global->__pyx_n_s_CONS +#define __pyx_n_s_CONSADDED __pyx_mstate_global->__pyx_n_s_CONSADDED +#define __pyx_n_s_CONSCHANGED __pyx_mstate_global->__pyx_n_s_CONSCHANGED +#define __pyx_n_s_CONST __pyx_mstate_global->__pyx_n_s_CONST +#define __pyx_n_u_CONTINUOUS __pyx_mstate_global->__pyx_n_u_CONTINUOUS +#define __pyx_n_s_COUNTER __pyx_mstate_global->__pyx_n_s_COUNTER +#define __pyx_n_s_CPSOLVER __pyx_mstate_global->__pyx_n_s_CPSOLVER +#define __pyx_n_s_CUTOFF __pyx_mstate_global->__pyx_n_s_CUTOFF +#define __pyx_kp_u_Can_only_support_constraints_wit __pyx_mstate_global->__pyx_kp_u_Can_only_support_constraints_wit +#define __pyx_kp_u_Can_t_evaluate_constraints_as_bo __pyx_mstate_global->__pyx_kp_u_Can_t_evaluate_constraints_as_bo +#define __pyx_kp_u_Cannot_set_value_to_a_freed_solu __pyx_mstate_global->__pyx_kp_u_Cannot_set_value_to_a_freed_solu +#define __pyx_n_u_CardinalityCons __pyx_mstate_global->__pyx_n_u_CardinalityCons +#define __pyx_n_s_Column __pyx_mstate_global->__pyx_n_s_Column +#define __pyx_n_s_Column___reduce_cython __pyx_mstate_global->__pyx_n_s_Column___reduce_cython +#define __pyx_n_s_Column___setstate_cython __pyx_mstate_global->__pyx_n_s_Column___setstate_cython +#define __pyx_n_s_Column_getBasisStatus __pyx_mstate_global->__pyx_n_s_Column_getBasisStatus +#define __pyx_n_s_Column_getLPPos __pyx_mstate_global->__pyx_n_s_Column_getLPPos +#define __pyx_n_s_Column_getLb __pyx_mstate_global->__pyx_n_s_Column_getLb +#define __pyx_n_s_Column_getObjCoeff __pyx_mstate_global->__pyx_n_s_Column_getObjCoeff +#define __pyx_n_s_Column_getPrimsol __pyx_mstate_global->__pyx_n_s_Column_getPrimsol +#define __pyx_n_s_Column_getUb __pyx_mstate_global->__pyx_n_s_Column_getUb +#define __pyx_n_s_Column_getVar __pyx_mstate_global->__pyx_n_s_Column_getVar +#define __pyx_n_s_Column_isIntegral __pyx_mstate_global->__pyx_n_s_Column_isIntegral +#define __pyx_n_s_Conshdlr __pyx_mstate_global->__pyx_n_s_Conshdlr +#define __pyx_n_s_Conshdlr___reduce_cython __pyx_mstate_global->__pyx_n_s_Conshdlr___reduce_cython +#define __pyx_n_s_Conshdlr___setstate_cython __pyx_mstate_global->__pyx_n_s_Conshdlr___setstate_cython +#define __pyx_n_s_Conshdlr_consactive __pyx_mstate_global->__pyx_n_s_Conshdlr_consactive +#define __pyx_n_s_Conshdlr_conscheck __pyx_mstate_global->__pyx_n_s_Conshdlr_conscheck +#define __pyx_n_s_Conshdlr_conscopy __pyx_mstate_global->__pyx_n_s_Conshdlr_conscopy +#define __pyx_n_s_Conshdlr_consdeactive __pyx_mstate_global->__pyx_n_s_Conshdlr_consdeactive +#define __pyx_n_s_Conshdlr_consdelete __pyx_mstate_global->__pyx_n_s_Conshdlr_consdelete +#define __pyx_n_s_Conshdlr_consdelvars __pyx_mstate_global->__pyx_n_s_Conshdlr_consdelvars +#define __pyx_n_s_Conshdlr_consdisable __pyx_mstate_global->__pyx_n_s_Conshdlr_consdisable +#define __pyx_n_s_Conshdlr_consenable __pyx_mstate_global->__pyx_n_s_Conshdlr_consenable +#define __pyx_n_s_Conshdlr_consenfolp __pyx_mstate_global->__pyx_n_s_Conshdlr_consenfolp +#define __pyx_n_s_Conshdlr_consenfops __pyx_mstate_global->__pyx_n_s_Conshdlr_consenfops +#define __pyx_n_s_Conshdlr_consenforelax __pyx_mstate_global->__pyx_n_s_Conshdlr_consenforelax +#define __pyx_n_s_Conshdlr_consexit __pyx_mstate_global->__pyx_n_s_Conshdlr_consexit +#define __pyx_n_s_Conshdlr_consexitpre __pyx_mstate_global->__pyx_n_s_Conshdlr_consexitpre +#define __pyx_n_s_Conshdlr_consexitsol __pyx_mstate_global->__pyx_n_s_Conshdlr_consexitsol +#define __pyx_n_s_Conshdlr_consfree __pyx_mstate_global->__pyx_n_s_Conshdlr_consfree +#define __pyx_n_s_Conshdlr_consgetdivebdchgs __pyx_mstate_global->__pyx_n_s_Conshdlr_consgetdivebdchgs +#define __pyx_n_s_Conshdlr_consgetnvars __pyx_mstate_global->__pyx_n_s_Conshdlr_consgetnvars +#define __pyx_n_s_Conshdlr_consgetpermsymgraph __pyx_mstate_global->__pyx_n_s_Conshdlr_consgetpermsymgraph +#define __pyx_n_s_Conshdlr_consgetsignedpermsymgra __pyx_mstate_global->__pyx_n_s_Conshdlr_consgetsignedpermsymgra +#define __pyx_n_s_Conshdlr_consgetvars __pyx_mstate_global->__pyx_n_s_Conshdlr_consgetvars +#define __pyx_n_s_Conshdlr_consinit __pyx_mstate_global->__pyx_n_s_Conshdlr_consinit +#define __pyx_n_s_Conshdlr_consinitlp __pyx_mstate_global->__pyx_n_s_Conshdlr_consinitlp +#define __pyx_n_s_Conshdlr_consinitpre __pyx_mstate_global->__pyx_n_s_Conshdlr_consinitpre +#define __pyx_n_s_Conshdlr_consinitsol __pyx_mstate_global->__pyx_n_s_Conshdlr_consinitsol +#define __pyx_n_s_Conshdlr_conslock __pyx_mstate_global->__pyx_n_s_Conshdlr_conslock +#define __pyx_n_s_Conshdlr_consparse __pyx_mstate_global->__pyx_n_s_Conshdlr_consparse +#define __pyx_n_s_Conshdlr_conspresol __pyx_mstate_global->__pyx_n_s_Conshdlr_conspresol +#define __pyx_n_s_Conshdlr_consprint __pyx_mstate_global->__pyx_n_s_Conshdlr_consprint +#define __pyx_n_s_Conshdlr_consprop __pyx_mstate_global->__pyx_n_s_Conshdlr_consprop +#define __pyx_n_s_Conshdlr_consresprop __pyx_mstate_global->__pyx_n_s_Conshdlr_consresprop +#define __pyx_n_s_Conshdlr_conssepalp __pyx_mstate_global->__pyx_n_s_Conshdlr_conssepalp +#define __pyx_n_s_Conshdlr_conssepasol __pyx_mstate_global->__pyx_n_s_Conshdlr_conssepasol +#define __pyx_n_s_Conshdlr_constrans __pyx_mstate_global->__pyx_n_s_Conshdlr_constrans +#define __pyx_n_s_Constant __pyx_mstate_global->__pyx_n_s_Constant +#define __pyx_n_s_Constant___reduce_cython __pyx_mstate_global->__pyx_n_s_Constant___reduce_cython +#define __pyx_n_s_Constant___setstate_cython __pyx_mstate_global->__pyx_n_s_Constant___setstate_cython +#define __pyx_kp_u_Constant_offsets_in_objective_ar __pyx_mstate_global->__pyx_kp_u_Constant_offsets_in_objective_ar +#define __pyx_n_s_Constraint __pyx_mstate_global->__pyx_n_s_Constraint +#define __pyx_n_s_Constraint___reduce_cython __pyx_mstate_global->__pyx_n_s_Constraint___reduce_cython +#define __pyx_n_s_Constraint___setstate_cython __pyx_mstate_global->__pyx_n_s_Constraint___setstate_cython +#define __pyx_n_s_Constraint_getConshdlrName __pyx_mstate_global->__pyx_n_s_Constraint_getConshdlrName +#define __pyx_n_s_Constraint_isActive __pyx_mstate_global->__pyx_n_s_Constraint_isActive +#define __pyx_n_s_Constraint_isChecked __pyx_mstate_global->__pyx_n_s_Constraint_isChecked +#define __pyx_n_s_Constraint_isDynamic __pyx_mstate_global->__pyx_n_s_Constraint_isDynamic +#define __pyx_n_s_Constraint_isEnforced __pyx_mstate_global->__pyx_n_s_Constraint_isEnforced +#define __pyx_n_s_Constraint_isInitial __pyx_mstate_global->__pyx_n_s_Constraint_isInitial +#define __pyx_n_s_Constraint_isLinear __pyx_mstate_global->__pyx_n_s_Constraint_isLinear +#define __pyx_n_s_Constraint_isLocal __pyx_mstate_global->__pyx_n_s_Constraint_isLocal +#define __pyx_n_s_Constraint_isModifiable __pyx_mstate_global->__pyx_n_s_Constraint_isModifiable +#define __pyx_n_s_Constraint_isNonlinear __pyx_mstate_global->__pyx_n_s_Constraint_isNonlinear +#define __pyx_n_s_Constraint_isOriginal __pyx_mstate_global->__pyx_n_s_Constraint_isOriginal +#define __pyx_n_s_Constraint_isPropagated __pyx_mstate_global->__pyx_n_s_Constraint_isPropagated +#define __pyx_n_s_Constraint_isRemovable __pyx_mstate_global->__pyx_n_s_Constraint_isRemovable +#define __pyx_n_s_Constraint_isSeparated __pyx_mstate_global->__pyx_n_s_Constraint_isSeparated +#define __pyx_n_s_Constraint_isStickingAtNode __pyx_mstate_global->__pyx_n_s_Constraint_isStickingAtNode +#define __pyx_n_s_Cutsel __pyx_mstate_global->__pyx_n_s_Cutsel +#define __pyx_n_s_Cutsel___reduce_cython __pyx_mstate_global->__pyx_n_s_Cutsel___reduce_cython +#define __pyx_n_s_Cutsel___setstate_cython __pyx_mstate_global->__pyx_n_s_Cutsel___setstate_cython +#define __pyx_n_s_Cutsel_cutselexit __pyx_mstate_global->__pyx_n_s_Cutsel_cutselexit +#define __pyx_n_s_Cutsel_cutselexitsol __pyx_mstate_global->__pyx_n_s_Cutsel_cutselexitsol +#define __pyx_n_s_Cutsel_cutselfree __pyx_mstate_global->__pyx_n_s_Cutsel_cutselfree +#define __pyx_n_s_Cutsel_cutselinit __pyx_mstate_global->__pyx_n_s_Cutsel_cutselinit +#define __pyx_n_s_Cutsel_cutselinitsol __pyx_mstate_global->__pyx_n_s_Cutsel_cutselinitsol +#define __pyx_n_s_Cutsel_cutselselect __pyx_mstate_global->__pyx_n_s_Cutsel_cutselselect +#define __pyx_n_s_DEADEND __pyx_mstate_global->__pyx_n_s_DEADEND +#define __pyx_n_s_DEFAULT __pyx_mstate_global->__pyx_n_s_DEFAULT +#define __pyx_n_s_DELAYED __pyx_mstate_global->__pyx_n_s_DELAYED +#define __pyx_n_s_DIDNOTFIND __pyx_mstate_global->__pyx_n_s_DIDNOTFIND +#define __pyx_n_s_DIDNOTRUN __pyx_mstate_global->__pyx_n_s_DIDNOTRUN +#define __pyx_n_s_DISABLED __pyx_mstate_global->__pyx_n_s_DISABLED +#define __pyx_n_s_DOMCHANGED __pyx_mstate_global->__pyx_n_s_DOMCHANGED +#define __pyx_n_s_DOWNWARDS __pyx_mstate_global->__pyx_n_s_DOWNWARDS +#define __pyx_n_s_DUALLIMIT __pyx_mstate_global->__pyx_n_s_DUALLIMIT +#define __pyx_n_s_DURINGLPLOOP __pyx_mstate_global->__pyx_n_s_DURINGLPLOOP +#define __pyx_n_s_DURINGPRESOLLOOP __pyx_mstate_global->__pyx_n_s_DURINGPRESOLLOOP +#define __pyx_n_s_DURINGPRICINGLOOP __pyx_mstate_global->__pyx_n_s_DURINGPRICINGLOOP +#define __pyx_n_s_DomainChanges __pyx_mstate_global->__pyx_n_s_DomainChanges +#define __pyx_n_s_DomainChanges___reduce_cython __pyx_mstate_global->__pyx_n_s_DomainChanges___reduce_cython +#define __pyx_n_s_DomainChanges___setstate_cython __pyx_mstate_global->__pyx_n_s_DomainChanges___setstate_cython +#define __pyx_n_s_DomainChanges_getBoundchgs __pyx_mstate_global->__pyx_n_s_DomainChanges_getBoundchgs +#define __pyx_n_s_EASYCIP __pyx_mstate_global->__pyx_n_s_EASYCIP +#define __pyx_n_s_ERROR __pyx_mstate_global->__pyx_n_s_ERROR +#define __pyx_n_s_EXHAUSTIVE __pyx_mstate_global->__pyx_n_s_EXHAUSTIVE +#define __pyx_n_s_EXITPRESOLVE __pyx_mstate_global->__pyx_n_s_EXITPRESOLVE +#define __pyx_n_s_EXITSOLVE __pyx_mstate_global->__pyx_n_s_EXITSOLVE +#define __pyx_n_s_Event __pyx_mstate_global->__pyx_n_s_Event +#define __pyx_n_s_EventNames __pyx_mstate_global->__pyx_n_s_EventNames +#define __pyx_n_s_Event___reduce_cython __pyx_mstate_global->__pyx_n_s_Event___reduce_cython +#define __pyx_n_s_Event___setstate_cython __pyx_mstate_global->__pyx_n_s_Event___setstate_cython +#define __pyx_n_s_Event__getEventNames __pyx_mstate_global->__pyx_n_s_Event__getEventNames +#define __pyx_n_s_Event_getName __pyx_mstate_global->__pyx_n_s_Event_getName +#define __pyx_n_s_Event_getNewBound __pyx_mstate_global->__pyx_n_s_Event_getNewBound +#define __pyx_n_s_Event_getNode __pyx_mstate_global->__pyx_n_s_Event_getNode +#define __pyx_n_s_Event_getOldBound __pyx_mstate_global->__pyx_n_s_Event_getOldBound +#define __pyx_n_s_Event_getRow __pyx_mstate_global->__pyx_n_s_Event_getRow +#define __pyx_n_s_Event_getType __pyx_mstate_global->__pyx_n_s_Event_getType +#define __pyx_n_s_Event_getVar __pyx_mstate_global->__pyx_n_s_Event_getVar +#define __pyx_n_s_Eventhdlr __pyx_mstate_global->__pyx_n_s_Eventhdlr +#define __pyx_n_s_Eventhdlr___reduce_cython __pyx_mstate_global->__pyx_n_s_Eventhdlr___reduce_cython +#define __pyx_n_s_Eventhdlr___setstate_cython __pyx_mstate_global->__pyx_n_s_Eventhdlr___setstate_cython +#define __pyx_n_s_Eventhdlr_eventcopy __pyx_mstate_global->__pyx_n_s_Eventhdlr_eventcopy +#define __pyx_n_s_Eventhdlr_eventdelete __pyx_mstate_global->__pyx_n_s_Eventhdlr_eventdelete +#define __pyx_n_s_Eventhdlr_eventexec __pyx_mstate_global->__pyx_n_s_Eventhdlr_eventexec +#define __pyx_n_s_Eventhdlr_eventexit __pyx_mstate_global->__pyx_n_s_Eventhdlr_eventexit +#define __pyx_n_s_Eventhdlr_eventexitsol __pyx_mstate_global->__pyx_n_s_Eventhdlr_eventexitsol +#define __pyx_n_s_Eventhdlr_eventfree __pyx_mstate_global->__pyx_n_s_Eventhdlr_eventfree +#define __pyx_n_s_Eventhdlr_eventinit __pyx_mstate_global->__pyx_n_s_Eventhdlr_eventinit +#define __pyx_n_s_Eventhdlr_eventinitsol __pyx_mstate_global->__pyx_n_s_Eventhdlr_eventinitsol +#define __pyx_n_s_Expr __pyx_mstate_global->__pyx_n_s_Expr +#define __pyx_kp_u_ExprCons __pyx_mstate_global->__pyx_kp_u_ExprCons +#define __pyx_n_s_ExprCons_2 __pyx_mstate_global->__pyx_n_s_ExprCons_2 +#define __pyx_n_s_ExprCons___reduce_cython __pyx_mstate_global->__pyx_n_s_ExprCons___reduce_cython +#define __pyx_n_s_ExprCons___setstate_cython __pyx_mstate_global->__pyx_n_s_ExprCons___setstate_cython +#define __pyx_kp_u_ExprCons_already_has_lower_bound __pyx_mstate_global->__pyx_kp_u_ExprCons_already_has_lower_bound +#define __pyx_kp_u_ExprCons_already_has_upper_bound __pyx_mstate_global->__pyx_kp_u_ExprCons_already_has_upper_bound +#define __pyx_n_s_ExprCons_normalize __pyx_mstate_global->__pyx_n_s_ExprCons_normalize +#define __pyx_n_s_Expr___reduce_cython __pyx_mstate_global->__pyx_n_s_Expr___reduce_cython +#define __pyx_n_s_Expr___setstate_cython __pyx_mstate_global->__pyx_n_s_Expr___setstate_cython +#define __pyx_n_s_Expr_degree __pyx_mstate_global->__pyx_n_s_Expr_degree +#define __pyx_n_s_Expr_normalize __pyx_mstate_global->__pyx_n_s_Expr_normalize +#define __pyx_kp_u_Expr_s __pyx_mstate_global->__pyx_kp_u_Expr_s +#define __pyx_n_s_FAST __pyx_mstate_global->__pyx_n_s_FAST +#define __pyx_n_s_FEASIBILITY __pyx_mstate_global->__pyx_n_s_FEASIBILITY +#define __pyx_n_s_FEASIBLE __pyx_mstate_global->__pyx_n_s_FEASIBLE +#define __pyx_n_s_FIRSTLPSOLVED __pyx_mstate_global->__pyx_n_s_FIRSTLPSOLVED +#define __pyx_n_s_FIXED __pyx_mstate_global->__pyx_n_s_FIXED +#define __pyx_n_s_FOCUSNODE __pyx_mstate_global->__pyx_n_s_FOCUSNODE +#define __pyx_n_s_FORK __pyx_mstate_global->__pyx_n_s_FORK +#define __pyx_n_s_FOUNDSOL __pyx_mstate_global->__pyx_n_s_FOUNDSOL +#define __pyx_n_s_FREE __pyx_mstate_global->__pyx_n_s_FREE +#define __pyx_n_s_FREETRANS __pyx_mstate_global->__pyx_n_s_FREETRANS +#define __pyx_n_s_GAPLIMIT __pyx_mstate_global->__pyx_n_s_GAPLIMIT +#define __pyx_n_s_GBDCHANGED __pyx_mstate_global->__pyx_n_s_GBDCHANGED +#define __pyx_n_s_GHOLEADDED __pyx_mstate_global->__pyx_n_s_GHOLEADDED +#define __pyx_n_s_GHOLECHANGED __pyx_mstate_global->__pyx_n_s_GHOLECHANGED +#define __pyx_n_s_GHOLEREMOVED __pyx_mstate_global->__pyx_n_s_GHOLEREMOVED +#define __pyx_n_s_GLBCHANGED __pyx_mstate_global->__pyx_n_s_GLBCHANGED +#define __pyx_n_s_GUBCHANGED __pyx_mstate_global->__pyx_n_s_GUBCHANGED +#define __pyx_n_s_GenExpr __pyx_mstate_global->__pyx_n_s_GenExpr +#define __pyx_n_s_GenExpr___reduce_cython __pyx_mstate_global->__pyx_n_s_GenExpr___reduce_cython +#define __pyx_n_s_GenExpr___setstate_cython __pyx_mstate_global->__pyx_n_s_GenExpr___setstate_cython +#define __pyx_n_s_GenExpr_degree __pyx_mstate_global->__pyx_n_s_GenExpr_degree +#define __pyx_n_s_GenExpr_getOp __pyx_mstate_global->__pyx_n_s_GenExpr_getOp +#define __pyx_kp_u_Given_constraint_list_is_not_ite __pyx_mstate_global->__pyx_kp_u_Given_constraint_list_is_not_ite +#define __pyx_kp_u_Given_constraint_list_is_not_ite_2 __pyx_mstate_global->__pyx_kp_u_Given_constraint_list_is_not_ite_2 +#define __pyx_n_s_HARDLP __pyx_mstate_global->__pyx_n_s_HARDLP +#define __pyx_n_s_HOLECHANGED __pyx_mstate_global->__pyx_n_s_HOLECHANGED +#define __pyx_n_s_Heur __pyx_mstate_global->__pyx_n_s_Heur +#define __pyx_n_s_Heur___reduce_cython __pyx_mstate_global->__pyx_n_s_Heur___reduce_cython +#define __pyx_n_s_Heur___setstate_cython __pyx_mstate_global->__pyx_n_s_Heur___setstate_cython +#define __pyx_n_s_Heur_heurexec __pyx_mstate_global->__pyx_n_s_Heur_heurexec +#define __pyx_n_s_Heur_heurexit __pyx_mstate_global->__pyx_n_s_Heur_heurexit +#define __pyx_n_s_Heur_heurexitsol __pyx_mstate_global->__pyx_n_s_Heur_heurexitsol +#define __pyx_n_s_Heur_heurfree __pyx_mstate_global->__pyx_n_s_Heur_heurfree +#define __pyx_n_s_Heur_heurinit __pyx_mstate_global->__pyx_n_s_Heur_heurinit +#define __pyx_n_s_Heur_heurinitsol __pyx_mstate_global->__pyx_n_s_Heur_heurinitsol +#define __pyx_n_u_I __pyx_mstate_global->__pyx_n_u_I +#define __pyx_n_s_IMPLADDED __pyx_mstate_global->__pyx_n_s_IMPLADDED +#define __pyx_n_u_IMPLINT __pyx_mstate_global->__pyx_n_u_IMPLINT +#define __pyx_n_s_INFEASIBLE __pyx_mstate_global->__pyx_n_s_INFEASIBLE +#define __pyx_n_s_INFORUNBD __pyx_mstate_global->__pyx_n_s_INFORUNBD +#define __pyx_n_s_INIT __pyx_mstate_global->__pyx_n_s_INIT +#define __pyx_n_s_INITPRESOLVE __pyx_mstate_global->__pyx_n_s_INITPRESOLVE +#define __pyx_n_s_INITSOLVE __pyx_mstate_global->__pyx_n_s_INITSOLVE +#define __pyx_n_u_INTEGER __pyx_mstate_global->__pyx_n_u_INTEGER +#define __pyx_n_s_IOError __pyx_mstate_global->__pyx_n_s_IOError +#define __pyx_n_s_ITERLIMIT __pyx_mstate_global->__pyx_n_s_ITERLIMIT +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_7 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_7 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_8 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_8 +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0_9 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_9 +#define __pyx_n_u_IndicatorCons __pyx_mstate_global->__pyx_n_u_IndicatorCons +#define __pyx_n_s_Iterable __pyx_mstate_global->__pyx_n_s_Iterable +#define __pyx_n_s_JUNCTION __pyx_mstate_global->__pyx_n_s_JUNCTION +#define __pyx_n_s_KeyError __pyx_mstate_global->__pyx_n_s_KeyError +#define __pyx_n_s_LBCHANGED __pyx_mstate_global->__pyx_n_s_LBCHANGED +#define __pyx_n_s_LBRELAXED __pyx_mstate_global->__pyx_n_s_LBRELAXED +#define __pyx_n_s_LBTIGHTENED __pyx_mstate_global->__pyx_n_s_LBTIGHTENED +#define __pyx_n_s_LC_NUMERIC __pyx_mstate_global->__pyx_n_s_LC_NUMERIC +#define __pyx_n_s_LEAF __pyx_mstate_global->__pyx_n_s_LEAF +#define __pyx_n_s_LHOLEADDED __pyx_mstate_global->__pyx_n_s_LHOLEADDED +#define __pyx_n_s_LHOLECHANGED __pyx_mstate_global->__pyx_n_s_LHOLECHANGED +#define __pyx_n_s_LHOLEREMOVED __pyx_mstate_global->__pyx_n_s_LHOLEREMOVED +#define __pyx_n_s_LP __pyx_mstate_global->__pyx_n_s_LP +#define __pyx_n_u_LP __pyx_mstate_global->__pyx_n_u_LP +#define __pyx_n_s_LPEVENT __pyx_mstate_global->__pyx_n_s_LPEVENT +#define __pyx_n_s_LPSOLVED __pyx_mstate_global->__pyx_n_s_LPSOLVED +#define __pyx_n_s_LP___reduce_cython __pyx_mstate_global->__pyx_n_s_LP___reduce_cython +#define __pyx_n_s_LP___setstate_cython __pyx_mstate_global->__pyx_n_s_LP___setstate_cython +#define __pyx_n_s_LP_addCol __pyx_mstate_global->__pyx_n_s_LP_addCol +#define __pyx_n_s_LP_addCols __pyx_mstate_global->__pyx_n_s_LP_addCols +#define __pyx_n_s_LP_addRow __pyx_mstate_global->__pyx_n_s_LP_addRow +#define __pyx_n_s_LP_addRows __pyx_mstate_global->__pyx_n_s_LP_addRows +#define __pyx_n_s_LP_chgBound __pyx_mstate_global->__pyx_n_s_LP_chgBound +#define __pyx_n_s_LP_chgCoef __pyx_mstate_global->__pyx_n_s_LP_chgCoef +#define __pyx_n_s_LP_chgObj __pyx_mstate_global->__pyx_n_s_LP_chgObj +#define __pyx_n_s_LP_chgSide __pyx_mstate_global->__pyx_n_s_LP_chgSide +#define __pyx_n_s_LP_clear __pyx_mstate_global->__pyx_n_s_LP_clear +#define __pyx_n_s_LP_delCols __pyx_mstate_global->__pyx_n_s_LP_delCols +#define __pyx_n_s_LP_delRows __pyx_mstate_global->__pyx_n_s_LP_delRows +#define __pyx_n_s_LP_getBasisInds __pyx_mstate_global->__pyx_n_s_LP_getBasisInds +#define __pyx_n_s_LP_getBounds __pyx_mstate_global->__pyx_n_s_LP_getBounds +#define __pyx_n_s_LP_getDual __pyx_mstate_global->__pyx_n_s_LP_getDual +#define __pyx_n_s_LP_getDualRay __pyx_mstate_global->__pyx_n_s_LP_getDualRay +#define __pyx_n_s_LP_getNIterations __pyx_mstate_global->__pyx_n_s_LP_getNIterations +#define __pyx_n_s_LP_getPrimal __pyx_mstate_global->__pyx_n_s_LP_getPrimal +#define __pyx_n_s_LP_getPrimalRay __pyx_mstate_global->__pyx_n_s_LP_getPrimalRay +#define __pyx_n_s_LP_getRedcost __pyx_mstate_global->__pyx_n_s_LP_getRedcost +#define __pyx_n_s_LP_getSides __pyx_mstate_global->__pyx_n_s_LP_getSides +#define __pyx_n_s_LP_infinity __pyx_mstate_global->__pyx_n_s_LP_infinity +#define __pyx_n_s_LP_isDualFeasible __pyx_mstate_global->__pyx_n_s_LP_isDualFeasible +#define __pyx_n_s_LP_isInfinity __pyx_mstate_global->__pyx_n_s_LP_isInfinity +#define __pyx_n_s_LP_isPrimalFeasible __pyx_mstate_global->__pyx_n_s_LP_isPrimalFeasible +#define __pyx_kp_u_LP_lp __pyx_mstate_global->__pyx_kp_u_LP_lp +#define __pyx_n_s_LP_ncols __pyx_mstate_global->__pyx_n_s_LP_ncols +#define __pyx_n_s_LP_nrows __pyx_mstate_global->__pyx_n_s_LP_nrows +#define __pyx_n_s_LP_readLP __pyx_mstate_global->__pyx_n_s_LP_readLP +#define __pyx_n_s_LP_solve __pyx_mstate_global->__pyx_n_s_LP_solve +#define __pyx_n_s_LP_writeLP __pyx_mstate_global->__pyx_n_s_LP_writeLP +#define __pyx_n_s_LookupError __pyx_mstate_global->__pyx_n_s_LookupError +#define __pyx_n_u_M __pyx_mstate_global->__pyx_n_u_M +#define __pyx_n_s_MAJOR __pyx_mstate_global->__pyx_n_s_MAJOR +#define __pyx_n_s_MEDIUM __pyx_mstate_global->__pyx_n_s_MEDIUM +#define __pyx_n_s_MEMLIMIT __pyx_mstate_global->__pyx_n_s_MEMLIMIT +#define __pyx_n_s_MINOR __pyx_mstate_global->__pyx_n_s_MINOR +#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError +#define __pyx_n_s_Model __pyx_mstate_global->__pyx_n_s_Model +#define __pyx_n_s_Model___reduce_cython __pyx_mstate_global->__pyx_n_s_Model___reduce_cython +#define __pyx_n_s_Model___setstate_cython __pyx_mstate_global->__pyx_n_s_Model___setstate_cython +#define __pyx_n_s_Model__createConsGenNonlinear __pyx_mstate_global->__pyx_n_s_Model__createConsGenNonlinear +#define __pyx_n_s_Model__createConsLinear __pyx_mstate_global->__pyx_n_s_Model__createConsLinear +#define __pyx_n_s_Model__createConsNonlinear __pyx_mstate_global->__pyx_n_s_Model__createConsNonlinear +#define __pyx_n_s_Model__createConsQuadratic __pyx_mstate_global->__pyx_n_s_Model__createConsQuadratic +#define __pyx_n_s_Model__getStageNames __pyx_mstate_global->__pyx_n_s_Model__getStageNames +#define __pyx_n_s_Model_activateBenders __pyx_mstate_global->__pyx_n_s_Model_activateBenders +#define __pyx_n_s_Model_addBendersSubproblem __pyx_mstate_global->__pyx_n_s_Model_addBendersSubproblem +#define __pyx_n_s_Model_addCoefLinear __pyx_mstate_global->__pyx_n_s_Model_addCoefLinear +#define __pyx_n_s_Model_addCons __pyx_mstate_global->__pyx_n_s_Model_addCons +#define __pyx_n_s_Model_addConsAnd __pyx_mstate_global->__pyx_n_s_Model_addConsAnd +#define __pyx_n_s_Model_addConsCardinality __pyx_mstate_global->__pyx_n_s_Model_addConsCardinality +#define __pyx_n_s_Model_addConsCoeff __pyx_mstate_global->__pyx_n_s_Model_addConsCoeff +#define __pyx_n_s_Model_addConsDisjunction __pyx_mstate_global->__pyx_n_s_Model_addConsDisjunction +#define __pyx_n_s_Model_addConsElemDisjunction __pyx_mstate_global->__pyx_n_s_Model_addConsElemDisjunction +#define __pyx_n_s_Model_addConsIndicator __pyx_mstate_global->__pyx_n_s_Model_addConsIndicator +#define __pyx_n_s_Model_addConsLocal __pyx_mstate_global->__pyx_n_s_Model_addConsLocal +#define __pyx_n_s_Model_addConsNode __pyx_mstate_global->__pyx_n_s_Model_addConsNode +#define __pyx_n_s_Model_addConsOr __pyx_mstate_global->__pyx_n_s_Model_addConsOr +#define __pyx_n_s_Model_addConsSOS1 __pyx_mstate_global->__pyx_n_s_Model_addConsSOS1 +#define __pyx_n_s_Model_addConsSOS2 __pyx_mstate_global->__pyx_n_s_Model_addConsSOS2 +#define __pyx_n_s_Model_addConsXor __pyx_mstate_global->__pyx_n_s_Model_addConsXor +#define __pyx_n_s_Model_addConss __pyx_mstate_global->__pyx_n_s_Model_addConss +#define __pyx_n_s_Model_addCut __pyx_mstate_global->__pyx_n_s_Model_addCut +#define __pyx_n_s_Model_addExprNonlinear __pyx_mstate_global->__pyx_n_s_Model_addExprNonlinear +#define __pyx_n_s_Model_addObjoffset __pyx_mstate_global->__pyx_n_s_Model_addObjoffset +#define __pyx_n_s_Model_addPoolCut __pyx_mstate_global->__pyx_n_s_Model_addPoolCut +#define __pyx_n_s_Model_addPyCons __pyx_mstate_global->__pyx_n_s_Model_addPyCons +#define __pyx_n_s_Model_addRowDive __pyx_mstate_global->__pyx_n_s_Model_addRowDive +#define __pyx_n_s_Model_addSol __pyx_mstate_global->__pyx_n_s_Model_addSol +#define __pyx_n_s_Model_addVar __pyx_mstate_global->__pyx_n_s_Model_addVar +#define __pyx_n_s_Model_addVarLocks __pyx_mstate_global->__pyx_n_s_Model_addVarLocks +#define __pyx_n_s_Model_addVarSOS1 __pyx_mstate_global->__pyx_n_s_Model_addVarSOS1 +#define __pyx_n_s_Model_addVarSOS2 __pyx_mstate_global->__pyx_n_s_Model_addVarSOS2 +#define __pyx_n_s_Model_addVarToRow __pyx_mstate_global->__pyx_n_s_Model_addVarToRow +#define __pyx_n_s_Model_appendVarSOS1 __pyx_mstate_global->__pyx_n_s_Model_appendVarSOS1 +#define __pyx_n_s_Model_appendVarSOS2 __pyx_mstate_global->__pyx_n_s_Model_appendVarSOS2 +#define __pyx_n_s_Model_applyCutsProbing __pyx_mstate_global->__pyx_n_s_Model_applyCutsProbing +#define __pyx_n_s_Model_backtrackProbing __pyx_mstate_global->__pyx_n_s_Model_backtrackProbing +#define __pyx_n_s_Model_branchVar __pyx_mstate_global->__pyx_n_s_Model_branchVar +#define __pyx_n_s_Model_branchVarVal __pyx_mstate_global->__pyx_n_s_Model_branchVarVal +#define __pyx_n_s_Model_cacheRowExtensions __pyx_mstate_global->__pyx_n_s_Model_cacheRowExtensions +#define __pyx_n_s_Model_calcChildEstimate __pyx_mstate_global->__pyx_n_s_Model_calcChildEstimate +#define __pyx_n_s_Model_calcNodeselPriority __pyx_mstate_global->__pyx_n_s_Model_calcNodeselPriority +#define __pyx_n_s_Model_catchEvent __pyx_mstate_global->__pyx_n_s_Model_catchEvent +#define __pyx_n_s_Model_catchRowEvent __pyx_mstate_global->__pyx_n_s_Model_catchRowEvent +#define __pyx_n_s_Model_catchVarEvent __pyx_mstate_global->__pyx_n_s_Model_catchVarEvent +#define __pyx_n_s_Model_checkBendersSubproblemOpti __pyx_mstate_global->__pyx_n_s_Model_checkBendersSubproblemOpti +#define __pyx_n_s_Model_checkQuadraticNonlinear __pyx_mstate_global->__pyx_n_s_Model_checkQuadraticNonlinear +#define __pyx_n_s_Model_checkSol __pyx_mstate_global->__pyx_n_s_Model_checkSol +#define __pyx_n_s_Model_chgCoefLinear __pyx_mstate_global->__pyx_n_s_Model_chgCoefLinear +#define __pyx_n_s_Model_chgLhs __pyx_mstate_global->__pyx_n_s_Model_chgLhs +#define __pyx_n_s_Model_chgReoptObjective __pyx_mstate_global->__pyx_n_s_Model_chgReoptObjective +#define __pyx_n_s_Model_chgRhs __pyx_mstate_global->__pyx_n_s_Model_chgRhs +#define __pyx_n_s_Model_chgRowLhsDive __pyx_mstate_global->__pyx_n_s_Model_chgRowLhsDive +#define __pyx_n_s_Model_chgRowRhsDive __pyx_mstate_global->__pyx_n_s_Model_chgRowRhsDive +#define __pyx_n_s_Model_chgVarBranchPriority __pyx_mstate_global->__pyx_n_s_Model_chgVarBranchPriority +#define __pyx_n_s_Model_chgVarLb __pyx_mstate_global->__pyx_n_s_Model_chgVarLb +#define __pyx_n_s_Model_chgVarLbDive __pyx_mstate_global->__pyx_n_s_Model_chgVarLbDive +#define __pyx_n_s_Model_chgVarLbGlobal __pyx_mstate_global->__pyx_n_s_Model_chgVarLbGlobal +#define __pyx_n_s_Model_chgVarLbNode __pyx_mstate_global->__pyx_n_s_Model_chgVarLbNode +#define __pyx_n_s_Model_chgVarLbProbing __pyx_mstate_global->__pyx_n_s_Model_chgVarLbProbing +#define __pyx_n_s_Model_chgVarObjDive __pyx_mstate_global->__pyx_n_s_Model_chgVarObjDive +#define __pyx_n_s_Model_chgVarObjProbing __pyx_mstate_global->__pyx_n_s_Model_chgVarObjProbing +#define __pyx_n_s_Model_chgVarType __pyx_mstate_global->__pyx_n_s_Model_chgVarType +#define __pyx_n_s_Model_chgVarUb __pyx_mstate_global->__pyx_n_s_Model_chgVarUb +#define __pyx_n_s_Model_chgVarUbDive __pyx_mstate_global->__pyx_n_s_Model_chgVarUbDive +#define __pyx_n_s_Model_chgVarUbGlobal __pyx_mstate_global->__pyx_n_s_Model_chgVarUbGlobal +#define __pyx_n_s_Model_chgVarUbNode __pyx_mstate_global->__pyx_n_s_Model_chgVarUbNode +#define __pyx_n_s_Model_chgVarUbProbing __pyx_mstate_global->__pyx_n_s_Model_chgVarUbProbing +#define __pyx_n_s_Model_computeBestSolSubproblems __pyx_mstate_global->__pyx_n_s_Model_computeBestSolSubproblems +#define __pyx_n_s_Model_constructLP __pyx_mstate_global->__pyx_n_s_Model_constructLP +#define __pyx_n_s_Model_count __pyx_mstate_global->__pyx_n_s_Model_count +#define __pyx_n_s_Model_createChild __pyx_mstate_global->__pyx_n_s_Model_createChild +#define __pyx_n_s_Model_createCons __pyx_mstate_global->__pyx_n_s_Model_createCons +#define __pyx_n_s_Model_createConsFromExpr __pyx_mstate_global->__pyx_n_s_Model_createConsFromExpr +#define __pyx_n_s_Model_createEmptyRowSepa __pyx_mstate_global->__pyx_n_s_Model_createEmptyRowSepa +#define __pyx_n_s_Model_createEmptyRowUnspec __pyx_mstate_global->__pyx_n_s_Model_createEmptyRowUnspec +#define __pyx_n_s_Model_createOrigSol __pyx_mstate_global->__pyx_n_s_Model_createOrigSol +#define __pyx_n_s_Model_createPartialSol __pyx_mstate_global->__pyx_n_s_Model_createPartialSol +#define __pyx_n_s_Model_createProbBasic __pyx_mstate_global->__pyx_n_s_Model_createProbBasic +#define __pyx_n_s_Model_createSol __pyx_mstate_global->__pyx_n_s_Model_createSol +#define __pyx_n_s_Model_delCoefLinear __pyx_mstate_global->__pyx_n_s_Model_delCoefLinear +#define __pyx_n_s_Model_delCons __pyx_mstate_global->__pyx_n_s_Model_delCons +#define __pyx_n_s_Model_delConsLocal __pyx_mstate_global->__pyx_n_s_Model_delConsLocal +#define __pyx_n_s_Model_delVar __pyx_mstate_global->__pyx_n_s_Model_delVar +#define __pyx_n_s_Model_disablePropagation __pyx_mstate_global->__pyx_n_s_Model_disablePropagation +#define __pyx_n_s_Model_dropEvent __pyx_mstate_global->__pyx_n_s_Model_dropEvent +#define __pyx_n_s_Model_dropRowEvent __pyx_mstate_global->__pyx_n_s_Model_dropRowEvent +#define __pyx_n_s_Model_dropVarEvent __pyx_mstate_global->__pyx_n_s_Model_dropVarEvent +#define __pyx_n_s_Model_enableReoptimization __pyx_mstate_global->__pyx_n_s_Model_enableReoptimization +#define __pyx_n_s_Model_endDive __pyx_mstate_global->__pyx_n_s_Model_endDive +#define __pyx_n_s_Model_endProbing __pyx_mstate_global->__pyx_n_s_Model_endProbing +#define __pyx_n_s_Model_epsilon __pyx_mstate_global->__pyx_n_s_Model_epsilon +#define __pyx_n_s_Model_feasFrac __pyx_mstate_global->__pyx_n_s_Model_feasFrac +#define __pyx_n_s_Model_feastol __pyx_mstate_global->__pyx_n_s_Model_feastol +#define __pyx_n_s_Model_fixVar __pyx_mstate_global->__pyx_n_s_Model_fixVar +#define __pyx_n_s_Model_fixVarProbing __pyx_mstate_global->__pyx_n_s_Model_fixVarProbing +#define __pyx_n_s_Model_flushRowExtensions __pyx_mstate_global->__pyx_n_s_Model_flushRowExtensions +#define __pyx_n_s_Model_frac __pyx_mstate_global->__pyx_n_s_Model_frac +#define __pyx_n_s_Model_freeBendersSubproblems __pyx_mstate_global->__pyx_n_s_Model_freeBendersSubproblems +#define __pyx_n_s_Model_freeProb __pyx_mstate_global->__pyx_n_s_Model_freeProb +#define __pyx_n_s_Model_freeReoptSolve __pyx_mstate_global->__pyx_n_s_Model_freeReoptSolve +#define __pyx_n_s_Model_freeSol __pyx_mstate_global->__pyx_n_s_Model_freeSol +#define __pyx_n_s_Model_freeTransform __pyx_mstate_global->__pyx_n_s_Model_freeTransform +#define __pyx_n_s_Model_from_ptr __pyx_mstate_global->__pyx_n_s_Model_from_ptr +#define __pyx_n_s_Model_getActivity __pyx_mstate_global->__pyx_n_s_Model_getActivity +#define __pyx_n_s_Model_getBendersAuxiliaryVar __pyx_mstate_global->__pyx_n_s_Model_getBendersAuxiliaryVar +#define __pyx_n_s_Model_getBendersSubproblem __pyx_mstate_global->__pyx_n_s_Model_getBendersSubproblem +#define __pyx_n_s_Model_getBendersVar __pyx_mstate_global->__pyx_n_s_Model_getBendersVar +#define __pyx_n_s_Model_getBestChild __pyx_mstate_global->__pyx_n_s_Model_getBestChild +#define __pyx_n_s_Model_getBestLeaf __pyx_mstate_global->__pyx_n_s_Model_getBestLeaf +#define __pyx_n_s_Model_getBestNode __pyx_mstate_global->__pyx_n_s_Model_getBestNode +#define __pyx_n_s_Model_getBestSibling __pyx_mstate_global->__pyx_n_s_Model_getBestSibling +#define __pyx_n_s_Model_getBestSol __pyx_mstate_global->__pyx_n_s_Model_getBestSol +#define __pyx_n_s_Model_getBestboundNode __pyx_mstate_global->__pyx_n_s_Model_getBestboundNode +#define __pyx_n_s_Model_getCondition __pyx_mstate_global->__pyx_n_s_Model_getCondition +#define __pyx_n_s_Model_getConsNVars __pyx_mstate_global->__pyx_n_s_Model_getConsNVars +#define __pyx_n_s_Model_getConsVars __pyx_mstate_global->__pyx_n_s_Model_getConsVars +#define __pyx_n_s_Model_getConss __pyx_mstate_global->__pyx_n_s_Model_getConss +#define __pyx_n_s_Model_getCurrentNode __pyx_mstate_global->__pyx_n_s_Model_getCurrentNode +#define __pyx_n_s_Model_getCutEfficacy __pyx_mstate_global->__pyx_n_s_Model_getCutEfficacy +#define __pyx_n_s_Model_getCutLPSolCutoffDistance __pyx_mstate_global->__pyx_n_s_Model_getCutLPSolCutoffDistance +#define __pyx_n_s_Model_getDepth __pyx_mstate_global->__pyx_n_s_Model_getDepth +#define __pyx_n_s_Model_getDualMultiplier __pyx_mstate_global->__pyx_n_s_Model_getDualMultiplier +#define __pyx_n_s_Model_getDualSolVal __pyx_mstate_global->__pyx_n_s_Model_getDualSolVal +#define __pyx_n_s_Model_getDualbound __pyx_mstate_global->__pyx_n_s_Model_getDualbound +#define __pyx_n_s_Model_getDualboundRoot __pyx_mstate_global->__pyx_n_s_Model_getDualboundRoot +#define __pyx_n_s_Model_getDualfarkasLinear __pyx_mstate_global->__pyx_n_s_Model_getDualfarkasLinear +#define __pyx_n_s_Model_getDualsolLinear __pyx_mstate_global->__pyx_n_s_Model_getDualsolLinear +#define __pyx_n_s_Model_getGap __pyx_mstate_global->__pyx_n_s_Model_getGap +#define __pyx_n_s_Model_getLPBInvARow __pyx_mstate_global->__pyx_n_s_Model_getLPBInvARow +#define __pyx_n_s_Model_getLPBInvRow __pyx_mstate_global->__pyx_n_s_Model_getLPBInvRow +#define __pyx_n_s_Model_getLPBasisInd __pyx_mstate_global->__pyx_n_s_Model_getLPBasisInd +#define __pyx_n_s_Model_getLPBranchCands __pyx_mstate_global->__pyx_n_s_Model_getLPBranchCands +#define __pyx_n_s_Model_getLPColsData __pyx_mstate_global->__pyx_n_s_Model_getLPColsData +#define __pyx_n_s_Model_getLPObjVal __pyx_mstate_global->__pyx_n_s_Model_getLPObjVal +#define __pyx_n_s_Model_getLPRowsData __pyx_mstate_global->__pyx_n_s_Model_getLPRowsData +#define __pyx_n_s_Model_getLPSolstat __pyx_mstate_global->__pyx_n_s_Model_getLPSolstat +#define __pyx_n_s_Model_getLhs __pyx_mstate_global->__pyx_n_s_Model_getLhs +#define __pyx_n_s_Model_getLocalEstimate __pyx_mstate_global->__pyx_n_s_Model_getLocalEstimate +#define __pyx_n_s_Model_getNBestSolsFound __pyx_mstate_global->__pyx_n_s_Model_getNBestSolsFound +#define __pyx_n_s_Model_getNBinVars __pyx_mstate_global->__pyx_n_s_Model_getNBinVars +#define __pyx_n_s_Model_getNChildren __pyx_mstate_global->__pyx_n_s_Model_getNChildren +#define __pyx_n_s_Model_getNConss __pyx_mstate_global->__pyx_n_s_Model_getNConss +#define __pyx_n_s_Model_getNCountedSols __pyx_mstate_global->__pyx_n_s_Model_getNCountedSols +#define __pyx_n_s_Model_getNCuts __pyx_mstate_global->__pyx_n_s_Model_getNCuts +#define __pyx_n_s_Model_getNCutsApplied __pyx_mstate_global->__pyx_n_s_Model_getNCutsApplied +#define __pyx_n_s_Model_getNFeasibleLeaves __pyx_mstate_global->__pyx_n_s_Model_getNFeasibleLeaves +#define __pyx_n_s_Model_getNInfeasibleLeaves __pyx_mstate_global->__pyx_n_s_Model_getNInfeasibleLeaves +#define __pyx_n_s_Model_getNIntVars __pyx_mstate_global->__pyx_n_s_Model_getNIntVars +#define __pyx_n_s_Model_getNLPCols __pyx_mstate_global->__pyx_n_s_Model_getNLPCols +#define __pyx_n_s_Model_getNLPIterations __pyx_mstate_global->__pyx_n_s_Model_getNLPIterations +#define __pyx_n_s_Model_getNLPRows __pyx_mstate_global->__pyx_n_s_Model_getNLPRows +#define __pyx_n_s_Model_getNLPs __pyx_mstate_global->__pyx_n_s_Model_getNLPs +#define __pyx_n_s_Model_getNLeaves __pyx_mstate_global->__pyx_n_s_Model_getNLeaves +#define __pyx_n_s_Model_getNLimSolsFound __pyx_mstate_global->__pyx_n_s_Model_getNLimSolsFound +#define __pyx_n_s_Model_getNNlRows __pyx_mstate_global->__pyx_n_s_Model_getNNlRows +#define __pyx_n_s_Model_getNNodes __pyx_mstate_global->__pyx_n_s_Model_getNNodes +#define __pyx_n_s_Model_getNReaders __pyx_mstate_global->__pyx_n_s_Model_getNReaders +#define __pyx_n_s_Model_getNSepaRounds __pyx_mstate_global->__pyx_n_s_Model_getNSepaRounds +#define __pyx_n_s_Model_getNSiblings __pyx_mstate_global->__pyx_n_s_Model_getNSiblings +#define __pyx_n_s_Model_getNSols __pyx_mstate_global->__pyx_n_s_Model_getNSols +#define __pyx_n_s_Model_getNSolsFound __pyx_mstate_global->__pyx_n_s_Model_getNSolsFound +#define __pyx_n_s_Model_getNTotalNodes __pyx_mstate_global->__pyx_n_s_Model_getNTotalNodes +#define __pyx_n_s_Model_getNVars __pyx_mstate_global->__pyx_n_s_Model_getNVars +#define __pyx_n_s_Model_getNlRowActivityBounds __pyx_mstate_global->__pyx_n_s_Model_getNlRowActivityBounds +#define __pyx_n_s_Model_getNlRowSolActivity __pyx_mstate_global->__pyx_n_s_Model_getNlRowSolActivity +#define __pyx_n_s_Model_getNlRowSolFeasibility __pyx_mstate_global->__pyx_n_s_Model_getNlRowSolFeasibility +#define __pyx_n_s_Model_getNlRows __pyx_mstate_global->__pyx_n_s_Model_getNlRows +#define __pyx_n_s_Model_getObjVal __pyx_mstate_global->__pyx_n_s_Model_getObjVal +#define __pyx_n_s_Model_getObjective __pyx_mstate_global->__pyx_n_s_Model_getObjective +#define __pyx_n_s_Model_getObjectiveSense __pyx_mstate_global->__pyx_n_s_Model_getObjectiveSense +#define __pyx_n_s_Model_getObjlimit __pyx_mstate_global->__pyx_n_s_Model_getObjlimit +#define __pyx_n_s_Model_getObjoffset __pyx_mstate_global->__pyx_n_s_Model_getObjoffset +#define __pyx_n_s_Model_getOpenNodes __pyx_mstate_global->__pyx_n_s_Model_getOpenNodes +#define __pyx_n_s_Model_getParam __pyx_mstate_global->__pyx_n_s_Model_getParam +#define __pyx_n_s_Model_getParams __pyx_mstate_global->__pyx_n_s_Model_getParams +#define __pyx_n_s_Model_getPresolvingTime __pyx_mstate_global->__pyx_n_s_Model_getPresolvingTime +#define __pyx_n_s_Model_getPrimalRay __pyx_mstate_global->__pyx_n_s_Model_getPrimalRay +#define __pyx_n_s_Model_getPrimalRayVal __pyx_mstate_global->__pyx_n_s_Model_getPrimalRayVal +#define __pyx_n_s_Model_getPrimalbound __pyx_mstate_global->__pyx_n_s_Model_getPrimalbound +#define __pyx_n_s_Model_getProbName __pyx_mstate_global->__pyx_n_s_Model_getProbName +#define __pyx_n_s_Model_getProbingDepth __pyx_mstate_global->__pyx_n_s_Model_getProbingDepth +#define __pyx_n_s_Model_getPseudoBranchCands __pyx_mstate_global->__pyx_n_s_Model_getPseudoBranchCands +#define __pyx_n_s_Model_getReadingTime __pyx_mstate_global->__pyx_n_s_Model_getReadingTime +#define __pyx_n_s_Model_getRhs __pyx_mstate_global->__pyx_n_s_Model_getRhs +#define __pyx_n_s_Model_getRowActivity __pyx_mstate_global->__pyx_n_s_Model_getRowActivity +#define __pyx_n_s_Model_getRowDualSol __pyx_mstate_global->__pyx_n_s_Model_getRowDualSol +#define __pyx_n_s_Model_getRowLPActivity __pyx_mstate_global->__pyx_n_s_Model_getRowLPActivity +#define __pyx_n_s_Model_getRowLinear __pyx_mstate_global->__pyx_n_s_Model_getRowLinear +#define __pyx_n_s_Model_getRowNumIntCols __pyx_mstate_global->__pyx_n_s_Model_getRowNumIntCols +#define __pyx_n_s_Model_getRowObjParallelism __pyx_mstate_global->__pyx_n_s_Model_getRowObjParallelism +#define __pyx_n_s_Model_getRowParallelism __pyx_mstate_global->__pyx_n_s_Model_getRowParallelism +#define __pyx_n_s_Model_getSlack __pyx_mstate_global->__pyx_n_s_Model_getSlack +#define __pyx_n_s_Model_getSlackVarIndicator __pyx_mstate_global->__pyx_n_s_Model_getSlackVarIndicator +#define __pyx_n_s_Model_getSolObjVal __pyx_mstate_global->__pyx_n_s_Model_getSolObjVal +#define __pyx_n_s_Model_getSolTime __pyx_mstate_global->__pyx_n_s_Model_getSolTime +#define __pyx_n_s_Model_getSolVal __pyx_mstate_global->__pyx_n_s_Model_getSolVal +#define __pyx_n_s_Model_getSols __pyx_mstate_global->__pyx_n_s_Model_getSols +#define __pyx_n_s_Model_getSolvingTime __pyx_mstate_global->__pyx_n_s_Model_getSolvingTime +#define __pyx_n_s_Model_getStage __pyx_mstate_global->__pyx_n_s_Model_getStage +#define __pyx_n_s_Model_getStageName __pyx_mstate_global->__pyx_n_s_Model_getStageName +#define __pyx_n_s_Model_getStatus __pyx_mstate_global->__pyx_n_s_Model_getStatus +#define __pyx_n_s_Model_getTermsQuadratic __pyx_mstate_global->__pyx_n_s_Model_getTermsQuadratic +#define __pyx_n_s_Model_getTotalTime __pyx_mstate_global->__pyx_n_s_Model_getTotalTime +#define __pyx_n_s_Model_getTransformedCons __pyx_mstate_global->__pyx_n_s_Model_getTransformedCons +#define __pyx_n_s_Model_getTransformedVar __pyx_mstate_global->__pyx_n_s_Model_getTransformedVar +#define __pyx_n_s_Model_getTreesizeEstimation __pyx_mstate_global->__pyx_n_s_Model_getTreesizeEstimation +#define __pyx_n_s_Model_getVal __pyx_mstate_global->__pyx_n_s_Model_getVal +#define __pyx_n_s_Model_getValsLinear __pyx_mstate_global->__pyx_n_s_Model_getValsLinear +#define __pyx_n_s_Model_getVarDict __pyx_mstate_global->__pyx_n_s_Model_getVarDict +#define __pyx_n_s_Model_getVarLbDive __pyx_mstate_global->__pyx_n_s_Model_getVarLbDive +#define __pyx_n_s_Model_getVarRedcost __pyx_mstate_global->__pyx_n_s_Model_getVarRedcost +#define __pyx_n_s_Model_getVarUbDive __pyx_mstate_global->__pyx_n_s_Model_getVarUbDive +#define __pyx_n_s_Model_getVars __pyx_mstate_global->__pyx_n_s_Model_getVars +#define __pyx_n_s_Model_hasPrimalRay __pyx_mstate_global->__pyx_n_s_Model_hasPrimalRay +#define __pyx_n_s_Model_hideOutput __pyx_mstate_global->__pyx_n_s_Model_hideOutput +#define __pyx_n_s_Model_inProbing __pyx_mstate_global->__pyx_n_s_Model_inProbing +#define __pyx_n_s_Model_inRepropagation __pyx_mstate_global->__pyx_n_s_Model_inRepropagation +#define __pyx_n_s_Model_includeBenders __pyx_mstate_global->__pyx_n_s_Model_includeBenders +#define __pyx_n_s_Model_includeBendersDefaultCuts __pyx_mstate_global->__pyx_n_s_Model_includeBendersDefaultCuts +#define __pyx_n_s_Model_includeBenderscut __pyx_mstate_global->__pyx_n_s_Model_includeBenderscut +#define __pyx_n_s_Model_includeBranchrule __pyx_mstate_global->__pyx_n_s_Model_includeBranchrule +#define __pyx_n_s_Model_includeConshdlr __pyx_mstate_global->__pyx_n_s_Model_includeConshdlr +#define __pyx_n_s_Model_includeCutsel __pyx_mstate_global->__pyx_n_s_Model_includeCutsel +#define __pyx_n_s_Model_includeDefaultPlugins __pyx_mstate_global->__pyx_n_s_Model_includeDefaultPlugins +#define __pyx_n_s_Model_includeEventhdlr __pyx_mstate_global->__pyx_n_s_Model_includeEventhdlr +#define __pyx_n_s_Model_includeHeur __pyx_mstate_global->__pyx_n_s_Model_includeHeur +#define __pyx_n_s_Model_includeNodesel __pyx_mstate_global->__pyx_n_s_Model_includeNodesel +#define __pyx_n_s_Model_includePresol __pyx_mstate_global->__pyx_n_s_Model_includePresol +#define __pyx_n_s_Model_includePricer __pyx_mstate_global->__pyx_n_s_Model_includePricer +#define __pyx_n_s_Model_includeProp __pyx_mstate_global->__pyx_n_s_Model_includeProp +#define __pyx_n_s_Model_includeReader __pyx_mstate_global->__pyx_n_s_Model_includeReader +#define __pyx_n_s_Model_includeRelax __pyx_mstate_global->__pyx_n_s_Model_includeRelax +#define __pyx_n_s_Model_includeSepa __pyx_mstate_global->__pyx_n_s_Model_includeSepa +#define __pyx_n_s_Model_infinity __pyx_mstate_global->__pyx_n_s_Model_infinity +#define __pyx_n_s_Model_initBendersDefault __pyx_mstate_global->__pyx_n_s_Model_initBendersDefault +#define __pyx_n_s_Model_interruptSolve __pyx_mstate_global->__pyx_n_s_Model_interruptSolve +#define __pyx_n_s_Model_isCutEfficacious __pyx_mstate_global->__pyx_n_s_Model_isCutEfficacious +#define __pyx_n_s_Model_isEQ __pyx_mstate_global->__pyx_n_s_Model_isEQ +#define __pyx_n_s_Model_isFeasEQ __pyx_mstate_global->__pyx_n_s_Model_isFeasEQ +#define __pyx_n_s_Model_isFeasIntegral __pyx_mstate_global->__pyx_n_s_Model_isFeasIntegral +#define __pyx_n_s_Model_isFeasNegative __pyx_mstate_global->__pyx_n_s_Model_isFeasNegative +#define __pyx_n_s_Model_isFeasZero __pyx_mstate_global->__pyx_n_s_Model_isFeasZero +#define __pyx_n_s_Model_isGE __pyx_mstate_global->__pyx_n_s_Model_isGE +#define __pyx_n_s_Model_isGT __pyx_mstate_global->__pyx_n_s_Model_isGT +#define __pyx_n_s_Model_isInfinity __pyx_mstate_global->__pyx_n_s_Model_isInfinity +#define __pyx_n_s_Model_isLE __pyx_mstate_global->__pyx_n_s_Model_isLE +#define __pyx_n_s_Model_isLPSolBasic __pyx_mstate_global->__pyx_n_s_Model_isLPSolBasic +#define __pyx_n_s_Model_isLT __pyx_mstate_global->__pyx_n_s_Model_isLT +#define __pyx_n_s_Model_isNLPConstructed __pyx_mstate_global->__pyx_n_s_Model_isNLPConstructed +#define __pyx_n_s_Model_isObjChangedProbing __pyx_mstate_global->__pyx_n_s_Model_isObjChangedProbing +#define __pyx_n_s_Model_isZero __pyx_mstate_global->__pyx_n_s_Model_isZero +#define __pyx_n_s_Model_lpiGetIterations __pyx_mstate_global->__pyx_n_s_Model_lpiGetIterations +#define __pyx_n_s_Model_newProbingNode __pyx_mstate_global->__pyx_n_s_Model_newProbingNode +#define __pyx_n_s_Model_optimize __pyx_mstate_global->__pyx_n_s_Model_optimize +#define __pyx_n_s_Model_presolve __pyx_mstate_global->__pyx_n_s_Model_presolve +#define __pyx_n_s_Model_printBestSol __pyx_mstate_global->__pyx_n_s_Model_printBestSol +#define __pyx_n_s_Model_printCons __pyx_mstate_global->__pyx_n_s_Model_printCons +#define __pyx_n_s_Model_printExternalCodeVersions __pyx_mstate_global->__pyx_n_s_Model_printExternalCodeVersions +#define __pyx_n_s_Model_printNlRow __pyx_mstate_global->__pyx_n_s_Model_printNlRow +#define __pyx_n_s_Model_printRow __pyx_mstate_global->__pyx_n_s_Model_printRow +#define __pyx_n_s_Model_printSol __pyx_mstate_global->__pyx_n_s_Model_printSol +#define __pyx_n_s_Model_printStatistics __pyx_mstate_global->__pyx_n_s_Model_printStatistics +#define __pyx_n_s_Model_printVersion __pyx_mstate_global->__pyx_n_s_Model_printVersion +#define __pyx_n_s_Model_propagateProbing __pyx_mstate_global->__pyx_n_s_Model_propagateProbing +#define __pyx_n_s_Model_readParams __pyx_mstate_global->__pyx_n_s_Model_readParams +#define __pyx_n_s_Model_readProblem __pyx_mstate_global->__pyx_n_s_Model_readProblem +#define __pyx_n_s_Model_readSol __pyx_mstate_global->__pyx_n_s_Model_readSol +#define __pyx_n_s_Model_readSolFile __pyx_mstate_global->__pyx_n_s_Model_readSolFile +#define __pyx_n_s_Model_redirectOutput __pyx_mstate_global->__pyx_n_s_Model_redirectOutput +#define __pyx_n_s_Model_relax __pyx_mstate_global->__pyx_n_s_Model_relax +#define __pyx_n_s_Model_releaseRow __pyx_mstate_global->__pyx_n_s_Model_releaseRow +#define __pyx_n_s_Model_repropagateNode __pyx_mstate_global->__pyx_n_s_Model_repropagateNode +#define __pyx_n_s_Model_resetParam __pyx_mstate_global->__pyx_n_s_Model_resetParam +#define __pyx_n_s_Model_resetParams __pyx_mstate_global->__pyx_n_s_Model_resetParams +#define __pyx_n_s_Model_restartSolve __pyx_mstate_global->__pyx_n_s_Model_restartSolve +#define __pyx_n_s_Model_separateSol __pyx_mstate_global->__pyx_n_s_Model_separateSol +#define __pyx_n_s_Model_setBendersSubproblemIsConv __pyx_mstate_global->__pyx_n_s_Model_setBendersSubproblemIsConv +#define __pyx_n_s_Model_setBoolParam __pyx_mstate_global->__pyx_n_s_Model_setBoolParam +#define __pyx_n_s_Model_setCharParam __pyx_mstate_global->__pyx_n_s_Model_setCharParam +#define __pyx_n_s_Model_setCheck __pyx_mstate_global->__pyx_n_s_Model_setCheck +#define __pyx_n_s_Model_setEmphasis __pyx_mstate_global->__pyx_n_s_Model_setEmphasis +#define __pyx_n_s_Model_setEnforced __pyx_mstate_global->__pyx_n_s_Model_setEnforced +#define __pyx_n_s_Model_setHeuristics __pyx_mstate_global->__pyx_n_s_Model_setHeuristics +#define __pyx_n_s_Model_setInitial __pyx_mstate_global->__pyx_n_s_Model_setInitial +#define __pyx_n_s_Model_setIntParam __pyx_mstate_global->__pyx_n_s_Model_setIntParam +#define __pyx_n_s_Model_setLogfile __pyx_mstate_global->__pyx_n_s_Model_setLogfile +#define __pyx_n_s_Model_setLongintParam __pyx_mstate_global->__pyx_n_s_Model_setLongintParam +#define __pyx_n_s_Model_setMaximize __pyx_mstate_global->__pyx_n_s_Model_setMaximize +#define __pyx_n_s_Model_setMinimize __pyx_mstate_global->__pyx_n_s_Model_setMinimize +#define __pyx_n_s_Model_setObjIntegral __pyx_mstate_global->__pyx_n_s_Model_setObjIntegral +#define __pyx_n_s_Model_setObjective __pyx_mstate_global->__pyx_n_s_Model_setObjective +#define __pyx_n_s_Model_setObjlimit __pyx_mstate_global->__pyx_n_s_Model_setObjlimit +#define __pyx_n_s_Model_setParam __pyx_mstate_global->__pyx_n_s_Model_setParam +#define __pyx_n_s_Model_setParams __pyx_mstate_global->__pyx_n_s_Model_setParams +#define __pyx_n_s_Model_setParamsCountsols __pyx_mstate_global->__pyx_n_s_Model_setParamsCountsols +#define __pyx_n_s_Model_setPresolve __pyx_mstate_global->__pyx_n_s_Model_setPresolve +#define __pyx_n_s_Model_setProbName __pyx_mstate_global->__pyx_n_s_Model_setProbName +#define __pyx_n_s_Model_setRealParam __pyx_mstate_global->__pyx_n_s_Model_setRealParam +#define __pyx_n_s_Model_setRelaxSolVal __pyx_mstate_global->__pyx_n_s_Model_setRelaxSolVal +#define __pyx_n_s_Model_setRemovable __pyx_mstate_global->__pyx_n_s_Model_setRemovable +#define __pyx_n_s_Model_setSeparating __pyx_mstate_global->__pyx_n_s_Model_setSeparating +#define __pyx_n_s_Model_setSolVal __pyx_mstate_global->__pyx_n_s_Model_setSolVal +#define __pyx_n_s_Model_setStringParam __pyx_mstate_global->__pyx_n_s_Model_setStringParam +#define __pyx_n_s_Model_setupBendersSubproblem __pyx_mstate_global->__pyx_n_s_Model_setupBendersSubproblem +#define __pyx_n_s_Model_solveBendersSubproblem __pyx_mstate_global->__pyx_n_s_Model_solveBendersSubproblem +#define __pyx_n_s_Model_solveConcurrent __pyx_mstate_global->__pyx_n_s_Model_solveConcurrent +#define __pyx_n_s_Model_solveDiveLP __pyx_mstate_global->__pyx_n_s_Model_solveDiveLP +#define __pyx_n_s_Model_solveProbingLP __pyx_mstate_global->__pyx_n_s_Model_solveProbingLP +#define __pyx_n_s_Model_startDive __pyx_mstate_global->__pyx_n_s_Model_startDive +#define __pyx_n_s_Model_startProbing __pyx_mstate_global->__pyx_n_s_Model_startProbing +#define __pyx_n_s_Model_tightenVarLb __pyx_mstate_global->__pyx_n_s_Model_tightenVarLb +#define __pyx_n_s_Model_tightenVarLbGlobal __pyx_mstate_global->__pyx_n_s_Model_tightenVarLbGlobal +#define __pyx_n_s_Model_tightenVarUb __pyx_mstate_global->__pyx_n_s_Model_tightenVarUb +#define __pyx_n_s_Model_tightenVarUbGlobal __pyx_mstate_global->__pyx_n_s_Model_tightenVarUbGlobal +#define __pyx_n_s_Model_to_ptr __pyx_mstate_global->__pyx_n_s_Model_to_ptr +#define __pyx_n_s_Model_trySol __pyx_mstate_global->__pyx_n_s_Model_trySol +#define __pyx_n_s_Model_updateBendersLowerbounds __pyx_mstate_global->__pyx_n_s_Model_updateBendersLowerbounds +#define __pyx_n_s_Model_updateNodeLowerbound __pyx_mstate_global->__pyx_n_s_Model_updateNodeLowerbound +#define __pyx_n_s_Model_version __pyx_mstate_global->__pyx_n_s_Model_version +#define __pyx_n_s_Model_writeBestSol __pyx_mstate_global->__pyx_n_s_Model_writeBestSol +#define __pyx_n_s_Model_writeBestTransSol __pyx_mstate_global->__pyx_n_s_Model_writeBestTransSol +#define __pyx_n_s_Model_writeLP __pyx_mstate_global->__pyx_n_s_Model_writeLP +#define __pyx_n_s_Model_writeName __pyx_mstate_global->__pyx_n_s_Model_writeName +#define __pyx_n_s_Model_writeParams __pyx_mstate_global->__pyx_n_s_Model_writeParams +#define __pyx_n_s_Model_writeProblem __pyx_mstate_global->__pyx_n_s_Model_writeProblem +#define __pyx_n_s_Model_writeSol __pyx_mstate_global->__pyx_n_s_Model_writeSol +#define __pyx_n_s_Model_writeStatistics __pyx_mstate_global->__pyx_n_s_Model_writeStatistics +#define __pyx_n_s_Model_writeTransSol __pyx_mstate_global->__pyx_n_s_Model_writeTransSol +#define __pyx_n_s_NEWROUND __pyx_mstate_global->__pyx_n_s_NEWROUND +#define __pyx_n_s_NLRow __pyx_mstate_global->__pyx_n_s_NLRow +#define __pyx_n_s_NLRow___reduce_cython __pyx_mstate_global->__pyx_n_s_NLRow___reduce_cython +#define __pyx_n_s_NLRow___setstate_cython __pyx_mstate_global->__pyx_n_s_NLRow___setstate_cython +#define __pyx_n_s_NLRow_getConstant __pyx_mstate_global->__pyx_n_s_NLRow_getConstant +#define __pyx_n_s_NLRow_getDualsol __pyx_mstate_global->__pyx_n_s_NLRow_getDualsol +#define __pyx_n_s_NLRow_getLhs __pyx_mstate_global->__pyx_n_s_NLRow_getLhs +#define __pyx_n_s_NLRow_getLinearTerms __pyx_mstate_global->__pyx_n_s_NLRow_getLinearTerms +#define __pyx_n_s_NLRow_getRhs __pyx_mstate_global->__pyx_n_s_NLRow_getRhs +#define __pyx_n_s_NODEBRANCHED __pyx_mstate_global->__pyx_n_s_NODEBRANCHED +#define __pyx_n_s_NODEDELETE __pyx_mstate_global->__pyx_n_s_NODEDELETE +#define __pyx_n_s_NODEEVENT __pyx_mstate_global->__pyx_n_s_NODEEVENT +#define __pyx_n_s_NODEFEASIBLE __pyx_mstate_global->__pyx_n_s_NODEFEASIBLE +#define __pyx_n_s_NODEFOCUSED __pyx_mstate_global->__pyx_n_s_NODEFOCUSED +#define __pyx_n_s_NODEINFEASIBLE __pyx_mstate_global->__pyx_n_s_NODEINFEASIBLE +#define __pyx_n_s_NODELIMIT __pyx_mstate_global->__pyx_n_s_NODELIMIT +#define __pyx_n_s_NODESOLVED __pyx_mstate_global->__pyx_n_s_NODESOLVED +#define __pyx_n_s_NONE __pyx_mstate_global->__pyx_n_s_NONE +#define __pyx_n_s_NOTSOLVED __pyx_mstate_global->__pyx_n_s_NOTSOLVED +#define __pyx_n_s_NUMERICS __pyx_mstate_global->__pyx_n_s_NUMERICS +#define __pyx_n_s_Node __pyx_mstate_global->__pyx_n_s_Node +#define __pyx_n_s_Node___reduce_cython __pyx_mstate_global->__pyx_n_s_Node___reduce_cython +#define __pyx_n_s_Node___setstate_cython __pyx_mstate_global->__pyx_n_s_Node___setstate_cython +#define __pyx_n_s_Node_getAddedConss __pyx_mstate_global->__pyx_n_s_Node_getAddedConss +#define __pyx_n_s_Node_getDepth __pyx_mstate_global->__pyx_n_s_Node_getDepth +#define __pyx_n_s_Node_getDomchg __pyx_mstate_global->__pyx_n_s_Node_getDomchg +#define __pyx_n_s_Node_getEstimate __pyx_mstate_global->__pyx_n_s_Node_getEstimate +#define __pyx_n_s_Node_getLowerbound __pyx_mstate_global->__pyx_n_s_Node_getLowerbound +#define __pyx_n_s_Node_getNAddedConss __pyx_mstate_global->__pyx_n_s_Node_getNAddedConss +#define __pyx_n_s_Node_getNDomchg __pyx_mstate_global->__pyx_n_s_Node_getNDomchg +#define __pyx_n_s_Node_getNParentBranchings __pyx_mstate_global->__pyx_n_s_Node_getNParentBranchings +#define __pyx_n_s_Node_getNumber __pyx_mstate_global->__pyx_n_s_Node_getNumber +#define __pyx_n_s_Node_getParent __pyx_mstate_global->__pyx_n_s_Node_getParent +#define __pyx_n_s_Node_getParentBranchings __pyx_mstate_global->__pyx_n_s_Node_getParentBranchings +#define __pyx_n_s_Node_getType __pyx_mstate_global->__pyx_n_s_Node_getType +#define __pyx_n_s_Node_isActive __pyx_mstate_global->__pyx_n_s_Node_isActive +#define __pyx_n_s_Node_isPropagatedAgain __pyx_mstate_global->__pyx_n_s_Node_isPropagatedAgain +#define __pyx_n_s_Nodesel __pyx_mstate_global->__pyx_n_s_Nodesel +#define __pyx_n_s_Nodesel___reduce_cython __pyx_mstate_global->__pyx_n_s_Nodesel___reduce_cython +#define __pyx_n_s_Nodesel___setstate_cython __pyx_mstate_global->__pyx_n_s_Nodesel___setstate_cython +#define __pyx_n_s_Nodesel_nodecomp __pyx_mstate_global->__pyx_n_s_Nodesel_nodecomp +#define __pyx_n_s_Nodesel_nodeexit __pyx_mstate_global->__pyx_n_s_Nodesel_nodeexit +#define __pyx_n_s_Nodesel_nodeexitsol __pyx_mstate_global->__pyx_n_s_Nodesel_nodeexitsol +#define __pyx_n_s_Nodesel_nodefree __pyx_mstate_global->__pyx_n_s_Nodesel_nodefree +#define __pyx_n_s_Nodesel_nodeinit __pyx_mstate_global->__pyx_n_s_Nodesel_nodeinit +#define __pyx_n_s_Nodesel_nodeinitsol __pyx_mstate_global->__pyx_n_s_Nodesel_nodeinitsol +#define __pyx_n_s_Nodesel_nodeselect __pyx_mstate_global->__pyx_n_s_Nodesel_nodeselect +#define __pyx_kp_u_Nonlinear_objective_functions_ar __pyx_mstate_global->__pyx_kp_u_Nonlinear_objective_functions_ar +#define __pyx_n_s_NotImplementedError __pyx_mstate_global->__pyx_n_s_NotImplementedError +#define __pyx_kp_u_Not_a_valid_parameter_name __pyx_mstate_global->__pyx_kp_u_Not_a_valid_parameter_name +#define __pyx_n_s_OBJCHANGED __pyx_mstate_global->__pyx_n_s_OBJCHANGED +#define __pyx_n_s_OBJLIMIT __pyx_mstate_global->__pyx_n_s_OBJLIMIT +#define __pyx_n_s_OFF __pyx_mstate_global->__pyx_n_s_OFF +#define __pyx_n_s_OPTIMAL __pyx_mstate_global->__pyx_n_s_OPTIMAL +#define __pyx_n_s_OPTIMALITY __pyx_mstate_global->__pyx_n_s_OPTIMALITY +#define __pyx_n_u_ORcons __pyx_mstate_global->__pyx_n_u_ORcons +#define __pyx_n_s_Op __pyx_mstate_global->__pyx_n_s_Op +#define __pyx_n_s_Operator __pyx_mstate_global->__pyx_n_s_Operator +#define __pyx_n_s_PATCH __pyx_mstate_global->__pyx_n_s_PATCH +#define __pyx_n_s_PHASEFEAS __pyx_mstate_global->__pyx_n_s_PHASEFEAS +#define __pyx_n_s_PHASEIMPROVE __pyx_mstate_global->__pyx_n_s_PHASEIMPROVE +#define __pyx_n_s_PHASEPROOF __pyx_mstate_global->__pyx_n_s_PHASEPROOF +#define __pyx_n_s_POORSOLFOUND __pyx_mstate_global->__pyx_n_s_POORSOLFOUND +#define __pyx_n_s_PRESOLVED __pyx_mstate_global->__pyx_n_s_PRESOLVED +#define __pyx_n_s_PRESOLVEROUND __pyx_mstate_global->__pyx_n_s_PRESOLVEROUND +#define __pyx_n_s_PRESOLVING __pyx_mstate_global->__pyx_n_s_PRESOLVING +#define __pyx_n_s_PRIMALLIMIT __pyx_mstate_global->__pyx_n_s_PRIMALLIMIT +#define __pyx_n_s_PROBINGNODE __pyx_mstate_global->__pyx_n_s_PROBINGNODE +#define __pyx_n_s_PROBLEM __pyx_mstate_global->__pyx_n_s_PROBLEM +#define __pyx_n_s_PSEUDO __pyx_mstate_global->__pyx_n_s_PSEUDO +#define __pyx_n_s_PSEUDOFORK __pyx_mstate_global->__pyx_n_s_PSEUDOFORK +#define __pyx_n_s_PY_SCIP_BENDERSENFOTYPE __pyx_mstate_global->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE +#define __pyx_n_s_PY_SCIP_BENDERSENFOTYPE___reduce __pyx_mstate_global->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___reduce +#define __pyx_n_s_PY_SCIP_BENDERSENFOTYPE___setsta __pyx_mstate_global->__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___setsta +#define __pyx_n_s_PY_SCIP_BRANCHDIR __pyx_mstate_global->__pyx_n_s_PY_SCIP_BRANCHDIR +#define __pyx_n_s_PY_SCIP_BRANCHDIR___reduce_cytho __pyx_mstate_global->__pyx_n_s_PY_SCIP_BRANCHDIR___reduce_cytho +#define __pyx_n_s_PY_SCIP_BRANCHDIR___setstate_cyt __pyx_mstate_global->__pyx_n_s_PY_SCIP_BRANCHDIR___setstate_cyt +#define __pyx_n_s_PY_SCIP_CALL __pyx_mstate_global->__pyx_n_s_PY_SCIP_CALL +#define __pyx_n_s_PY_SCIP_EVENTTYPE __pyx_mstate_global->__pyx_n_s_PY_SCIP_EVENTTYPE +#define __pyx_n_s_PY_SCIP_EVENTTYPE___reduce_cytho __pyx_mstate_global->__pyx_n_s_PY_SCIP_EVENTTYPE___reduce_cytho +#define __pyx_n_s_PY_SCIP_EVENTTYPE___setstate_cyt __pyx_mstate_global->__pyx_n_s_PY_SCIP_EVENTTYPE___setstate_cyt +#define __pyx_n_s_PY_SCIP_HEURTIMING __pyx_mstate_global->__pyx_n_s_PY_SCIP_HEURTIMING +#define __pyx_n_s_PY_SCIP_HEURTIMING___reduce_cyth __pyx_mstate_global->__pyx_n_s_PY_SCIP_HEURTIMING___reduce_cyth +#define __pyx_n_s_PY_SCIP_HEURTIMING___setstate_cy __pyx_mstate_global->__pyx_n_s_PY_SCIP_HEURTIMING___setstate_cy +#define __pyx_n_s_PY_SCIP_LPSOLSTAT __pyx_mstate_global->__pyx_n_s_PY_SCIP_LPSOLSTAT +#define __pyx_n_s_PY_SCIP_LPSOLSTAT___reduce_cytho __pyx_mstate_global->__pyx_n_s_PY_SCIP_LPSOLSTAT___reduce_cytho +#define __pyx_n_s_PY_SCIP_LPSOLSTAT___setstate_cyt __pyx_mstate_global->__pyx_n_s_PY_SCIP_LPSOLSTAT___setstate_cyt +#define __pyx_n_s_PY_SCIP_NODETYPE __pyx_mstate_global->__pyx_n_s_PY_SCIP_NODETYPE +#define __pyx_n_s_PY_SCIP_NODETYPE___reduce_cython __pyx_mstate_global->__pyx_n_s_PY_SCIP_NODETYPE___reduce_cython +#define __pyx_n_s_PY_SCIP_NODETYPE___setstate_cyth __pyx_mstate_global->__pyx_n_s_PY_SCIP_NODETYPE___setstate_cyth +#define __pyx_n_s_PY_SCIP_PARAMEMPHASIS __pyx_mstate_global->__pyx_n_s_PY_SCIP_PARAMEMPHASIS +#define __pyx_n_s_PY_SCIP_PARAMEMPHASIS___reduce_c __pyx_mstate_global->__pyx_n_s_PY_SCIP_PARAMEMPHASIS___reduce_c +#define __pyx_n_s_PY_SCIP_PARAMEMPHASIS___setstate __pyx_mstate_global->__pyx_n_s_PY_SCIP_PARAMEMPHASIS___setstate +#define __pyx_n_s_PY_SCIP_PARAMSETTING __pyx_mstate_global->__pyx_n_s_PY_SCIP_PARAMSETTING +#define __pyx_n_s_PY_SCIP_PARAMSETTING___reduce_cy __pyx_mstate_global->__pyx_n_s_PY_SCIP_PARAMSETTING___reduce_cy +#define __pyx_n_s_PY_SCIP_PARAMSETTING___setstate __pyx_mstate_global->__pyx_n_s_PY_SCIP_PARAMSETTING___setstate +#define __pyx_n_s_PY_SCIP_PRESOLTIMING __pyx_mstate_global->__pyx_n_s_PY_SCIP_PRESOLTIMING +#define __pyx_n_s_PY_SCIP_PRESOLTIMING___reduce_cy __pyx_mstate_global->__pyx_n_s_PY_SCIP_PRESOLTIMING___reduce_cy +#define __pyx_n_s_PY_SCIP_PRESOLTIMING___setstate __pyx_mstate_global->__pyx_n_s_PY_SCIP_PRESOLTIMING___setstate +#define __pyx_n_s_PY_SCIP_PROPTIMING __pyx_mstate_global->__pyx_n_s_PY_SCIP_PROPTIMING +#define __pyx_n_s_PY_SCIP_PROPTIMING___reduce_cyth __pyx_mstate_global->__pyx_n_s_PY_SCIP_PROPTIMING___reduce_cyth +#define __pyx_n_s_PY_SCIP_PROPTIMING___setstate_cy __pyx_mstate_global->__pyx_n_s_PY_SCIP_PROPTIMING___setstate_cy +#define __pyx_n_s_PY_SCIP_RESULT __pyx_mstate_global->__pyx_n_s_PY_SCIP_RESULT +#define __pyx_n_s_PY_SCIP_RESULT___reduce_cython __pyx_mstate_global->__pyx_n_s_PY_SCIP_RESULT___reduce_cython +#define __pyx_n_s_PY_SCIP_RESULT___setstate_cython __pyx_mstate_global->__pyx_n_s_PY_SCIP_RESULT___setstate_cython +#define __pyx_n_s_PY_SCIP_ROWORIGINTYPE __pyx_mstate_global->__pyx_n_s_PY_SCIP_ROWORIGINTYPE +#define __pyx_n_s_PY_SCIP_ROWORIGINTYPE___reduce_c __pyx_mstate_global->__pyx_n_s_PY_SCIP_ROWORIGINTYPE___reduce_c +#define __pyx_n_s_PY_SCIP_ROWORIGINTYPE___setstate __pyx_mstate_global->__pyx_n_s_PY_SCIP_ROWORIGINTYPE___setstate +#define __pyx_n_s_PY_SCIP_STAGE __pyx_mstate_global->__pyx_n_s_PY_SCIP_STAGE +#define __pyx_n_s_PY_SCIP_STAGE___reduce_cython __pyx_mstate_global->__pyx_n_s_PY_SCIP_STAGE___reduce_cython +#define __pyx_n_s_PY_SCIP_STAGE___setstate_cython __pyx_mstate_global->__pyx_n_s_PY_SCIP_STAGE___setstate_cython +#define __pyx_n_s_PY_SCIP_STATUS __pyx_mstate_global->__pyx_n_s_PY_SCIP_STATUS +#define __pyx_n_s_PY_SCIP_STATUS___reduce_cython __pyx_mstate_global->__pyx_n_s_PY_SCIP_STATUS___reduce_cython +#define __pyx_n_s_PY_SCIP_STATUS___setstate_cython __pyx_mstate_global->__pyx_n_s_PY_SCIP_STATUS___setstate_cython +#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError +#define __pyx_n_s_PowExpr __pyx_mstate_global->__pyx_n_s_PowExpr +#define __pyx_n_s_PowExpr___reduce_cython __pyx_mstate_global->__pyx_n_s_PowExpr___reduce_cython +#define __pyx_n_s_PowExpr___setstate_cython __pyx_mstate_global->__pyx_n_s_PowExpr___setstate_cython +#define __pyx_n_s_Presol __pyx_mstate_global->__pyx_n_s_Presol +#define __pyx_n_s_Presol___reduce_cython __pyx_mstate_global->__pyx_n_s_Presol___reduce_cython +#define __pyx_n_s_Presol___setstate_cython __pyx_mstate_global->__pyx_n_s_Presol___setstate_cython +#define __pyx_n_s_Presol_presolexec __pyx_mstate_global->__pyx_n_s_Presol_presolexec +#define __pyx_n_s_Presol_presolexit __pyx_mstate_global->__pyx_n_s_Presol_presolexit +#define __pyx_n_s_Presol_presolexitpre __pyx_mstate_global->__pyx_n_s_Presol_presolexitpre +#define __pyx_n_s_Presol_presolfree __pyx_mstate_global->__pyx_n_s_Presol_presolfree +#define __pyx_n_s_Presol_presolinit __pyx_mstate_global->__pyx_n_s_Presol_presolinit +#define __pyx_n_s_Presol_presolinitpre __pyx_mstate_global->__pyx_n_s_Presol_presolinitpre +#define __pyx_n_s_Pricer __pyx_mstate_global->__pyx_n_s_Pricer +#define __pyx_n_s_Pricer___reduce_cython __pyx_mstate_global->__pyx_n_s_Pricer___reduce_cython +#define __pyx_n_s_Pricer___setstate_cython __pyx_mstate_global->__pyx_n_s_Pricer___setstate_cython +#define __pyx_n_s_Pricer_pricerexit __pyx_mstate_global->__pyx_n_s_Pricer_pricerexit +#define __pyx_n_s_Pricer_pricerexitsol __pyx_mstate_global->__pyx_n_s_Pricer_pricerexitsol +#define __pyx_n_s_Pricer_pricerfarkas __pyx_mstate_global->__pyx_n_s_Pricer_pricerfarkas +#define __pyx_n_s_Pricer_pricerfree __pyx_mstate_global->__pyx_n_s_Pricer_pricerfree +#define __pyx_n_s_Pricer_pricerinit __pyx_mstate_global->__pyx_n_s_Pricer_pricerinit +#define __pyx_n_s_Pricer_pricerinitsol __pyx_mstate_global->__pyx_n_s_Pricer_pricerinitsol +#define __pyx_n_s_Pricer_pricerredcost __pyx_mstate_global->__pyx_n_s_Pricer_pricerredcost +#define __pyx_n_s_ProdExpr __pyx_mstate_global->__pyx_n_s_ProdExpr +#define __pyx_n_s_ProdExpr___reduce_cython __pyx_mstate_global->__pyx_n_s_ProdExpr___reduce_cython +#define __pyx_n_s_ProdExpr___setstate_cython __pyx_mstate_global->__pyx_n_s_ProdExpr___setstate_cython +#define __pyx_n_s_Prop __pyx_mstate_global->__pyx_n_s_Prop +#define __pyx_n_s_Prop___reduce_cython __pyx_mstate_global->__pyx_n_s_Prop___reduce_cython +#define __pyx_n_s_Prop___setstate_cython __pyx_mstate_global->__pyx_n_s_Prop___setstate_cython +#define __pyx_n_s_Prop_propexec __pyx_mstate_global->__pyx_n_s_Prop_propexec +#define __pyx_n_s_Prop_propexit __pyx_mstate_global->__pyx_n_s_Prop_propexit +#define __pyx_n_s_Prop_propexitpre __pyx_mstate_global->__pyx_n_s_Prop_propexitpre +#define __pyx_n_s_Prop_propexitsol __pyx_mstate_global->__pyx_n_s_Prop_propexitsol +#define __pyx_n_s_Prop_propfree __pyx_mstate_global->__pyx_n_s_Prop_propfree +#define __pyx_n_s_Prop_propinit __pyx_mstate_global->__pyx_n_s_Prop_propinit +#define __pyx_n_s_Prop_propinitpre __pyx_mstate_global->__pyx_n_s_Prop_propinitpre +#define __pyx_n_s_Prop_propinitsol __pyx_mstate_global->__pyx_n_s_Prop_propinitsol +#define __pyx_n_s_Prop_proppresol __pyx_mstate_global->__pyx_n_s_Prop_proppresol +#define __pyx_n_s_Prop_propresprop __pyx_mstate_global->__pyx_n_s_Prop_propresprop +#define __pyx_kp_u_Provide_BOOLEAN_value_as_rhsvar __pyx_mstate_global->__pyx_kp_u_Provide_BOOLEAN_value_as_rhsvar +#define __pyx_n_s_PyCons __pyx_mstate_global->__pyx_n_s_PyCons +#define __pyx_n_s_PyRow __pyx_mstate_global->__pyx_n_s_PyRow +#define __pyx_n_s_REDUCEDDOM __pyx_mstate_global->__pyx_n_s_REDUCEDDOM +#define __pyx_n_s_REFOCUSNODE __pyx_mstate_global->__pyx_n_s_REFOCUSNODE +#define __pyx_n_s_RELAX __pyx_mstate_global->__pyx_n_s_RELAX +#define __pyx_n_s_REOPT __pyx_mstate_global->__pyx_n_s_REOPT +#define __pyx_n_s_RESTARTLIMIT __pyx_mstate_global->__pyx_n_s_RESTARTLIMIT +#define __pyx_n_s_ROWADDEDLP __pyx_mstate_global->__pyx_n_s_ROWADDEDLP +#define __pyx_n_s_ROWADDEDSEPA __pyx_mstate_global->__pyx_n_s_ROWADDEDSEPA +#define __pyx_n_s_ROWCHANGED __pyx_mstate_global->__pyx_n_s_ROWCHANGED +#define __pyx_n_s_ROWCOEFCHANGED __pyx_mstate_global->__pyx_n_s_ROWCOEFCHANGED +#define __pyx_n_s_ROWCONSTCHANGED __pyx_mstate_global->__pyx_n_s_ROWCONSTCHANGED +#define __pyx_n_s_ROWDELETEDLP __pyx_mstate_global->__pyx_n_s_ROWDELETEDLP +#define __pyx_n_s_ROWDELETEDSEPA __pyx_mstate_global->__pyx_n_s_ROWDELETEDSEPA +#define __pyx_n_s_ROWEVENT __pyx_mstate_global->__pyx_n_s_ROWEVENT +#define __pyx_n_s_ROWSIDECHANGED __pyx_mstate_global->__pyx_n_s_ROWSIDECHANGED +#define __pyx_kp_u_Ranged_ExprCons_is_not_well_defi __pyx_mstate_global->__pyx_kp_u_Ranged_ExprCons_is_not_well_defi +#define __pyx_n_s_Reader __pyx_mstate_global->__pyx_n_s_Reader +#define __pyx_n_s_Reader___reduce_cython __pyx_mstate_global->__pyx_n_s_Reader___reduce_cython +#define __pyx_n_s_Reader___setstate_cython __pyx_mstate_global->__pyx_n_s_Reader___setstate_cython +#define __pyx_n_s_Reader_readerfree __pyx_mstate_global->__pyx_n_s_Reader_readerfree +#define __pyx_n_s_Reader_readerread __pyx_mstate_global->__pyx_n_s_Reader_readerread +#define __pyx_n_s_Reader_readerwrite __pyx_mstate_global->__pyx_n_s_Reader_readerwrite +#define __pyx_n_s_Relax __pyx_mstate_global->__pyx_n_s_Relax +#define __pyx_n_s_Relax___reduce_cython __pyx_mstate_global->__pyx_n_s_Relax___reduce_cython +#define __pyx_n_s_Relax___setstate_cython __pyx_mstate_global->__pyx_n_s_Relax___setstate_cython +#define __pyx_n_s_Relax_relaxexec __pyx_mstate_global->__pyx_n_s_Relax_relaxexec +#define __pyx_n_s_Relax_relaxexit __pyx_mstate_global->__pyx_n_s_Relax_relaxexit +#define __pyx_n_s_Relax_relaxexitsol __pyx_mstate_global->__pyx_n_s_Relax_relaxexitsol +#define __pyx_n_s_Relax_relaxfree __pyx_mstate_global->__pyx_n_s_Relax_relaxfree +#define __pyx_n_s_Relax_relaxinit __pyx_mstate_global->__pyx_n_s_Relax_relaxinit +#define __pyx_n_s_Relax_relaxinitsol __pyx_mstate_global->__pyx_n_s_Relax_relaxinitsol +#define __pyx_n_s_Row __pyx_mstate_global->__pyx_n_s_Row +#define __pyx_n_s_Row___reduce_cython __pyx_mstate_global->__pyx_n_s_Row___reduce_cython +#define __pyx_n_s_Row___setstate_cython __pyx_mstate_global->__pyx_n_s_Row___setstate_cython +#define __pyx_n_s_Row_getBasisStatus __pyx_mstate_global->__pyx_n_s_Row_getBasisStatus +#define __pyx_n_s_Row_getCols __pyx_mstate_global->__pyx_n_s_Row_getCols +#define __pyx_n_s_Row_getConsOriginConshdlrtype __pyx_mstate_global->__pyx_n_s_Row_getConsOriginConshdlrtype +#define __pyx_n_s_Row_getConstant __pyx_mstate_global->__pyx_n_s_Row_getConstant +#define __pyx_n_s_Row_getLPPos __pyx_mstate_global->__pyx_n_s_Row_getLPPos +#define __pyx_n_s_Row_getLhs __pyx_mstate_global->__pyx_n_s_Row_getLhs +#define __pyx_n_s_Row_getNLPNonz __pyx_mstate_global->__pyx_n_s_Row_getNLPNonz +#define __pyx_n_s_Row_getNNonz __pyx_mstate_global->__pyx_n_s_Row_getNNonz +#define __pyx_n_s_Row_getNorm __pyx_mstate_global->__pyx_n_s_Row_getNorm +#define __pyx_n_s_Row_getOrigintype __pyx_mstate_global->__pyx_n_s_Row_getOrigintype +#define __pyx_n_s_Row_getRhs __pyx_mstate_global->__pyx_n_s_Row_getRhs +#define __pyx_n_s_Row_getVals __pyx_mstate_global->__pyx_n_s_Row_getVals +#define __pyx_n_s_Row_isInGlobalCutpool __pyx_mstate_global->__pyx_n_s_Row_isInGlobalCutpool +#define __pyx_n_s_Row_isIntegral __pyx_mstate_global->__pyx_n_s_Row_isIntegral +#define __pyx_n_s_Row_isLocal __pyx_mstate_global->__pyx_n_s_Row_isLocal +#define __pyx_n_s_Row_isModifiable __pyx_mstate_global->__pyx_n_s_Row_isModifiable +#define __pyx_n_s_Row_isRemovable __pyx_mstate_global->__pyx_n_s_Row_isRemovable +#define __pyx_n_s_SCIP_BOUNDTYPE_TO_STRING __pyx_mstate_global->__pyx_n_s_SCIP_BOUNDTYPE_TO_STRING +#define __pyx_kp_u_SCIP_a_required_plugin_was_not_f __pyx_mstate_global->__pyx_kp_u_SCIP_a_required_plugin_was_not_f +#define __pyx_kp_u_SCIP_cannot_create_file __pyx_mstate_global->__pyx_kp_u_SCIP_cannot_create_file +#define __pyx_kp_u_SCIP_does_not_support_nonlinear __pyx_mstate_global->__pyx_kp_u_SCIP_does_not_support_nonlinear +#define __pyx_kp_u_SCIP_error_in_LP_solver __pyx_mstate_global->__pyx_kp_u_SCIP_error_in_LP_solver +#define __pyx_kp_u_SCIP_error_in_input_data __pyx_mstate_global->__pyx_kp_u_SCIP_error_in_input_data +#define __pyx_kp_u_SCIP_file_not_found_error __pyx_mstate_global->__pyx_kp_u_SCIP_file_not_found_error +#define __pyx_kp_u_SCIP_insufficient_memory_error __pyx_mstate_global->__pyx_kp_u_SCIP_insufficient_memory_error +#define __pyx_kp_u_SCIP_maximal_branching_depth_lev __pyx_mstate_global->__pyx_kp_u_SCIP_maximal_branching_depth_lev +#define __pyx_kp_u_SCIP_method_cannot_be_called_at __pyx_mstate_global->__pyx_kp_u_SCIP_method_cannot_be_called_at +#define __pyx_kp_u_SCIP_method_returned_an_invalid __pyx_mstate_global->__pyx_kp_u_SCIP_method_returned_an_invalid +#define __pyx_kp_u_SCIP_no_problem_exists __pyx_mstate_global->__pyx_kp_u_SCIP_no_problem_exists +#define __pyx_kp_u_SCIP_read_error __pyx_mstate_global->__pyx_kp_u_SCIP_read_error +#define __pyx_kp_u_SCIP_reading_solution_from_file __pyx_mstate_global->__pyx_kp_u_SCIP_reading_solution_from_file +#define __pyx_kp_u_SCIP_returned_base_status_zero_f __pyx_mstate_global->__pyx_kp_u_SCIP_returned_base_status_zero_f +#define __pyx_kp_u_SCIP_returned_unknown_base_statu __pyx_mstate_global->__pyx_kp_u_SCIP_returned_unknown_base_statu +#define __pyx_kp_u_SCIP_the_given_key_is_already_ex __pyx_mstate_global->__pyx_kp_u_SCIP_the_given_key_is_already_ex +#define __pyx_kp_u_SCIP_the_parameter_is_not_of_the __pyx_mstate_global->__pyx_kp_u_SCIP_the_parameter_is_not_of_the +#define __pyx_kp_u_SCIP_the_parameter_with_the_give __pyx_mstate_global->__pyx_kp_u_SCIP_the_parameter_with_the_give +#define __pyx_kp_u_SCIP_the_value_is_invalid_for_th __pyx_mstate_global->__pyx_kp_u_SCIP_the_value_is_invalid_for_th +#define __pyx_kp_u_SCIP_unknown_return_code __pyx_mstate_global->__pyx_kp_u_SCIP_unknown_return_code +#define __pyx_kp_u_SCIP_unspecified_error __pyx_mstate_global->__pyx_kp_u_SCIP_unspecified_error +#define __pyx_kp_u_SCIP_was_compiled_without_task_p __pyx_mstate_global->__pyx_kp_u_SCIP_was_compiled_without_task_p +#define __pyx_kp_u_SCIP_write_error __pyx_mstate_global->__pyx_kp_u_SCIP_write_error +#define __pyx_n_u_SCIPgetSolVal __pyx_mstate_global->__pyx_n_u_SCIPgetSolVal +#define __pyx_n_s_SEPA __pyx_mstate_global->__pyx_n_s_SEPA +#define __pyx_n_s_SEPARATED __pyx_mstate_global->__pyx_n_s_SEPARATED +#define __pyx_n_s_SIBLING __pyx_mstate_global->__pyx_n_s_SIBLING +#define __pyx_n_s_SOLEVENT __pyx_mstate_global->__pyx_n_s_SOLEVENT +#define __pyx_n_s_SOLFOUND __pyx_mstate_global->__pyx_n_s_SOLFOUND +#define __pyx_n_s_SOLLIMIT __pyx_mstate_global->__pyx_n_s_SOLLIMIT +#define __pyx_n_s_SOLVED __pyx_mstate_global->__pyx_n_s_SOLVED +#define __pyx_n_s_SOLVELP __pyx_mstate_global->__pyx_n_s_SOLVELP +#define __pyx_n_s_SOLVING __pyx_mstate_global->__pyx_n_s_SOLVING +#define __pyx_n_u_SOS1cons __pyx_mstate_global->__pyx_n_u_SOS1cons +#define __pyx_n_u_SOS2cons __pyx_mstate_global->__pyx_n_u_SOS2cons +#define __pyx_n_s_STALLNODELIMIT __pyx_mstate_global->__pyx_n_s_STALLNODELIMIT +#define __pyx_n_s_SUBROOT __pyx_mstate_global->__pyx_n_s_SUBROOT +#define __pyx_n_s_SUCCESS __pyx_mstate_global->__pyx_n_s_SUCCESS +#define __pyx_n_s_SUSPENDED __pyx_mstate_global->__pyx_n_s_SUSPENDED +#define __pyx_n_s_SYNC __pyx_mstate_global->__pyx_n_s_SYNC +#define __pyx_n_s_Sepa __pyx_mstate_global->__pyx_n_s_Sepa +#define __pyx_n_s_Sepa___reduce_cython __pyx_mstate_global->__pyx_n_s_Sepa___reduce_cython +#define __pyx_n_s_Sepa___setstate_cython __pyx_mstate_global->__pyx_n_s_Sepa___setstate_cython +#define __pyx_n_s_Sepa_sepaexeclp __pyx_mstate_global->__pyx_n_s_Sepa_sepaexeclp +#define __pyx_n_s_Sepa_sepaexecsol __pyx_mstate_global->__pyx_n_s_Sepa_sepaexecsol +#define __pyx_n_s_Sepa_sepaexit __pyx_mstate_global->__pyx_n_s_Sepa_sepaexit +#define __pyx_n_s_Sepa_sepaexitsol __pyx_mstate_global->__pyx_n_s_Sepa_sepaexitsol +#define __pyx_n_s_Sepa_sepafree __pyx_mstate_global->__pyx_n_s_Sepa_sepafree +#define __pyx_n_s_Sepa_sepainit __pyx_mstate_global->__pyx_n_s_Sepa_sepainit +#define __pyx_n_s_Sepa_sepainitsol __pyx_mstate_global->__pyx_n_s_Sepa_sepainitsol +#define __pyx_n_s_Solution __pyx_mstate_global->__pyx_n_s_Solution +#define __pyx_n_s_Solution___reduce_cython __pyx_mstate_global->__pyx_n_s_Solution___reduce_cython +#define __pyx_n_s_Solution___setstate_cython __pyx_mstate_global->__pyx_n_s_Solution___setstate_cython +#define __pyx_n_s_Solution__checkStage __pyx_mstate_global->__pyx_n_s_Solution__checkStage +#define __pyx_n_s_Solution__evaluate __pyx_mstate_global->__pyx_n_s_Solution__evaluate +#define __pyx_n_s_StageNames __pyx_mstate_global->__pyx_n_s_StageNames +#define __pyx_n_s_StopIteration __pyx_mstate_global->__pyx_n_s_StopIteration +#define __pyx_n_s_SumExpr __pyx_mstate_global->__pyx_n_s_SumExpr +#define __pyx_n_s_SumExpr___reduce_cython __pyx_mstate_global->__pyx_n_s_SumExpr___reduce_cython +#define __pyx_n_s_SumExpr___setstate_cython __pyx_mstate_global->__pyx_n_s_SumExpr___setstate_cython +#define __pyx_n_s_TIMELIMIT __pyx_mstate_global->__pyx_n_s_TIMELIMIT +#define __pyx_n_s_TOTALNODELIMIT __pyx_mstate_global->__pyx_n_s_TOTALNODELIMIT +#define __pyx_n_s_TRANSFORMED __pyx_mstate_global->__pyx_n_s_TRANSFORMED +#define __pyx_n_s_TRANSFORMING __pyx_mstate_global->__pyx_n_s_TRANSFORMING +#define __pyx_n_s_Term __pyx_mstate_global->__pyx_n_s_Term +#define __pyx_n_s_Term___add __pyx_mstate_global->__pyx_n_s_Term___add +#define __pyx_n_s_Term___eq __pyx_mstate_global->__pyx_n_s_Term___eq +#define __pyx_n_s_Term___getitem __pyx_mstate_global->__pyx_n_s_Term___getitem +#define __pyx_n_s_Term___hash __pyx_mstate_global->__pyx_n_s_Term___hash +#define __pyx_n_s_Term___init __pyx_mstate_global->__pyx_n_s_Term___init +#define __pyx_n_s_Term___init___locals_genexpr __pyx_mstate_global->__pyx_n_s_Term___init___locals_genexpr +#define __pyx_n_s_Term___init___locals_lambda __pyx_mstate_global->__pyx_n_s_Term___init___locals_lambda +#define __pyx_n_s_Term___len __pyx_mstate_global->__pyx_n_s_Term___len +#define __pyx_n_s_Term___repr __pyx_mstate_global->__pyx_n_s_Term___repr +#define __pyx_kp_u_Term_s __pyx_mstate_global->__pyx_kp_u_Term_s +#define __pyx_kp_u_The_constraint_handler_s_does_no __pyx_mstate_global->__pyx_kp_u_The_constraint_handler_s_does_no +#define __pyx_kp_u_The_given_capsule_does_not_conta __pyx_mstate_global->__pyx_kp_u_The_given_capsule_does_not_conta +#define __pyx_kp_u_The_given_variable_is_not_a_pyva __pyx_mstate_global->__pyx_kp_u_The_given_variable_is_not_a_pyva +#define __pyx_kp_u_The_problem_does_not_have_a_prim __pyx_mstate_global->__pyx_kp_u_The_problem_does_not_have_a_prim +#define __pyx_kp_s_This_is_a_monomial_term __pyx_mstate_global->__pyx_kp_s_This_is_a_monomial_term +#define __pyx_kp_u_To_create_a_solution_you_should __pyx_mstate_global->__pyx_kp_u_To_create_a_solution_you_should +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s_UBCHANGED __pyx_mstate_global->__pyx_n_s_UBCHANGED +#define __pyx_n_s_UBRELAXED __pyx_mstate_global->__pyx_n_s_UBRELAXED +#define __pyx_n_s_UBTIGHTENED __pyx_mstate_global->__pyx_n_s_UBTIGHTENED +#define __pyx_n_s_UNBOUNDED __pyx_mstate_global->__pyx_n_s_UNBOUNDED +#define __pyx_n_s_UNBOUNDEDRAY __pyx_mstate_global->__pyx_n_s_UNBOUNDEDRAY +#define __pyx_n_s_UNKNOWN __pyx_mstate_global->__pyx_n_s_UNKNOWN +#define __pyx_n_s_UNSPEC __pyx_mstate_global->__pyx_n_s_UNSPEC +#define __pyx_n_s_UPWARDS __pyx_mstate_global->__pyx_n_s_UPWARDS +#define __pyx_n_s_USERINTERRUPT __pyx_mstate_global->__pyx_n_s_USERINTERRUPT +#define __pyx_n_s_UnaryExpr __pyx_mstate_global->__pyx_n_s_UnaryExpr +#define __pyx_n_s_UnaryExpr___reduce_cython __pyx_mstate_global->__pyx_n_s_UnaryExpr___reduce_cython +#define __pyx_n_s_UnaryExpr___setstate_cython __pyx_mstate_global->__pyx_n_s_UnaryExpr___setstate_cython +#define __pyx_n_s_Union __pyx_mstate_global->__pyx_n_s_Union +#define __pyx_kp_s_Union_Expr_GenExpr __pyx_mstate_global->__pyx_kp_s_Union_Expr_GenExpr +#define __pyx_n_s_VARADDED __pyx_mstate_global->__pyx_n_s_VARADDED +#define __pyx_n_s_VARCHANGED __pyx_mstate_global->__pyx_n_s_VARCHANGED +#define __pyx_n_s_VARDELETED __pyx_mstate_global->__pyx_n_s_VARDELETED +#define __pyx_n_s_VAREVENT __pyx_mstate_global->__pyx_n_s_VAREVENT +#define __pyx_n_s_VARFIXED __pyx_mstate_global->__pyx_n_s_VARFIXED +#define __pyx_n_s_VARUNLOCKED __pyx_mstate_global->__pyx_n_s_VARUNLOCKED +#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError +#define __pyx_n_s_VarExpr __pyx_mstate_global->__pyx_n_s_VarExpr +#define __pyx_n_s_VarExpr___reduce_cython __pyx_mstate_global->__pyx_n_s_VarExpr___reduce_cython +#define __pyx_n_s_VarExpr___setstate_cython __pyx_mstate_global->__pyx_n_s_VarExpr___setstate_cython +#define __pyx_n_s_Variable __pyx_mstate_global->__pyx_n_s_Variable +#define __pyx_n_s_Variable___reduce_cython __pyx_mstate_global->__pyx_n_s_Variable___reduce_cython +#define __pyx_n_s_Variable___setstate_cython __pyx_mstate_global->__pyx_n_s_Variable___setstate_cython +#define __pyx_n_s_Variable_getCol __pyx_mstate_global->__pyx_n_s_Variable_getCol +#define __pyx_n_s_Variable_getIndex __pyx_mstate_global->__pyx_n_s_Variable_getIndex +#define __pyx_n_s_Variable_getLPSol __pyx_mstate_global->__pyx_n_s_Variable_getLPSol +#define __pyx_n_s_Variable_getLbGlobal __pyx_mstate_global->__pyx_n_s_Variable_getLbGlobal +#define __pyx_n_s_Variable_getLbLocal __pyx_mstate_global->__pyx_n_s_Variable_getLbLocal +#define __pyx_n_s_Variable_getLbOriginal __pyx_mstate_global->__pyx_n_s_Variable_getLbOriginal +#define __pyx_n_s_Variable_getObj __pyx_mstate_global->__pyx_n_s_Variable_getObj +#define __pyx_n_s_Variable_getUbGlobal __pyx_mstate_global->__pyx_n_s_Variable_getUbGlobal +#define __pyx_n_s_Variable_getUbLocal __pyx_mstate_global->__pyx_n_s_Variable_getUbLocal +#define __pyx_n_s_Variable_getUbOriginal __pyx_mstate_global->__pyx_n_s_Variable_getUbOriginal +#define __pyx_n_s_Variable_isInLP __pyx_mstate_global->__pyx_n_s_Variable_isInLP +#define __pyx_n_s_Variable_isOriginal __pyx_mstate_global->__pyx_n_s_Variable_isOriginal +#define __pyx_n_s_Variable_ptr __pyx_mstate_global->__pyx_n_s_Variable_ptr +#define __pyx_n_s_Variable_vtype __pyx_mstate_global->__pyx_n_s_Variable_vtype +#define __pyx_n_s_Warning __pyx_mstate_global->__pyx_n_s_Warning +#define __pyx_n_u_XORcons __pyx_mstate_global->__pyx_n_u_XORcons +#define __pyx_n_s_ZeroDivisionError __pyx_mstate_global->__pyx_n_s_ZeroDivisionError +#define __pyx_kp_u__10 __pyx_mstate_global->__pyx_kp_u__10 +#define __pyx_kp_u__114 __pyx_mstate_global->__pyx_kp_u__114 +#define __pyx_n_s__1188 __pyx_mstate_global->__pyx_n_s__1188 +#define __pyx_n_s__126 __pyx_mstate_global->__pyx_n_s__126 +#define __pyx_kp_u__126 __pyx_mstate_global->__pyx_kp_u__126 +#define __pyx_kp_u__162 __pyx_mstate_global->__pyx_kp_u__162 +#define __pyx_kp_u__163 __pyx_mstate_global->__pyx_kp_u__163 +#define __pyx_kp_u__164 __pyx_mstate_global->__pyx_kp_u__164 +#define __pyx_kp_u__165 __pyx_mstate_global->__pyx_kp_u__165 +#define __pyx_kp_u__2 __pyx_mstate_global->__pyx_kp_u__2 +#define __pyx_kp_u__441 __pyx_mstate_global->__pyx_kp_u__441 +#define __pyx_kp_u__442 __pyx_mstate_global->__pyx_kp_u__442 +#define __pyx_kp_u__6 __pyx_mstate_global->__pyx_kp_u__6 +#define __pyx_kp_u__79 __pyx_mstate_global->__pyx_kp_u__79 +#define __pyx_kp_u__89 __pyx_mstate_global->__pyx_kp_u__89 +#define __pyx_kp_u__9 __pyx_mstate_global->__pyx_kp_u__9 +#define __pyx_n_u__94 __pyx_mstate_global->__pyx_n_u__94 +#define __pyx_n_u_abs __pyx_mstate_global->__pyx_n_u_abs +#define __pyx_n_s_absfile __pyx_mstate_global->__pyx_n_s_absfile +#define __pyx_n_s_abspath __pyx_mstate_global->__pyx_n_s_abspath +#define __pyx_n_s_activateBenders __pyx_mstate_global->__pyx_n_s_activateBenders +#define __pyx_n_s_activeone __pyx_mstate_global->__pyx_n_s_activeone +#define __pyx_n_s_activity __pyx_mstate_global->__pyx_n_s_activity +#define __pyx_n_s_add __pyx_mstate_global->__pyx_n_s_add +#define __pyx_n_s_addBendersSubproblem __pyx_mstate_global->__pyx_n_s_addBendersSubproblem +#define __pyx_n_s_addCoefLinear __pyx_mstate_global->__pyx_n_s_addCoefLinear +#define __pyx_n_s_addCol __pyx_mstate_global->__pyx_n_s_addCol +#define __pyx_n_s_addCols __pyx_mstate_global->__pyx_n_s_addCols +#define __pyx_n_s_addCols_locals_genexpr __pyx_mstate_global->__pyx_n_s_addCols_locals_genexpr +#define __pyx_n_s_addCons __pyx_mstate_global->__pyx_n_s_addCons +#define __pyx_n_s_addConsAnd __pyx_mstate_global->__pyx_n_s_addConsAnd +#define __pyx_n_s_addConsCardinality __pyx_mstate_global->__pyx_n_s_addConsCardinality +#define __pyx_n_s_addConsCoeff __pyx_mstate_global->__pyx_n_s_addConsCoeff +#define __pyx_n_s_addConsDisjunction __pyx_mstate_global->__pyx_n_s_addConsDisjunction +#define __pyx_n_s_addConsDisjunction_locals_ensure __pyx_mstate_global->__pyx_n_s_addConsDisjunction_locals_ensure +#define __pyx_n_s_addConsElemDisjunction __pyx_mstate_global->__pyx_n_s_addConsElemDisjunction +#define __pyx_n_s_addConsIndicator __pyx_mstate_global->__pyx_n_s_addConsIndicator +#define __pyx_n_s_addConsLocal __pyx_mstate_global->__pyx_n_s_addConsLocal +#define __pyx_n_s_addConsNode __pyx_mstate_global->__pyx_n_s_addConsNode +#define __pyx_n_s_addConsOr __pyx_mstate_global->__pyx_n_s_addConsOr +#define __pyx_n_s_addConsSOS1 __pyx_mstate_global->__pyx_n_s_addConsSOS1 +#define __pyx_n_s_addConsSOS2 __pyx_mstate_global->__pyx_n_s_addConsSOS2 +#define __pyx_n_s_addConsXor __pyx_mstate_global->__pyx_n_s_addConsXor +#define __pyx_n_s_addConss __pyx_mstate_global->__pyx_n_s_addConss +#define __pyx_n_s_addConss_locals_ensure_iterable __pyx_mstate_global->__pyx_n_s_addConss_locals_ensure_iterable +#define __pyx_n_s_addCut __pyx_mstate_global->__pyx_n_s_addCut +#define __pyx_n_s_addExprNonlinear __pyx_mstate_global->__pyx_n_s_addExprNonlinear +#define __pyx_kp_u_addExprNonlinear_can_only_be_cal __pyx_mstate_global->__pyx_kp_u_addExprNonlinear_can_only_be_cal +#define __pyx_kp_u_addExprNonlinear_cannot_be_calle __pyx_mstate_global->__pyx_kp_u_addExprNonlinear_cannot_be_calle +#define __pyx_n_s_addObjoffset __pyx_mstate_global->__pyx_n_s_addObjoffset +#define __pyx_n_s_addPoolCut __pyx_mstate_global->__pyx_n_s_addPoolCut +#define __pyx_n_s_addPyCons __pyx_mstate_global->__pyx_n_s_addPyCons +#define __pyx_n_s_addRow __pyx_mstate_global->__pyx_n_s_addRow +#define __pyx_n_s_addRowDive __pyx_mstate_global->__pyx_n_s_addRowDive +#define __pyx_n_s_addRows __pyx_mstate_global->__pyx_n_s_addRows +#define __pyx_n_s_addRows_locals_genexpr __pyx_mstate_global->__pyx_n_s_addRows_locals_genexpr +#define __pyx_n_s_addSol __pyx_mstate_global->__pyx_n_s_addSol +#define __pyx_n_s_addVar __pyx_mstate_global->__pyx_n_s_addVar +#define __pyx_n_s_addVarLocks __pyx_mstate_global->__pyx_n_s_addVarLocks +#define __pyx_n_s_addVarSOS1 __pyx_mstate_global->__pyx_n_s_addVarSOS1 +#define __pyx_n_s_addVarSOS2 __pyx_mstate_global->__pyx_n_s_addVarSOS2 +#define __pyx_n_s_addVarToRow __pyx_mstate_global->__pyx_n_s_addVarToRow +#define __pyx_n_s_add_2 __pyx_mstate_global->__pyx_n_s_add_2 +#define __pyx_n_s_addedconss __pyx_mstate_global->__pyx_n_s_addedconss +#define __pyx_n_s_addedconsssize __pyx_mstate_global->__pyx_n_s_addedconsssize +#define __pyx_n_s_allowaddcons __pyx_mstate_global->__pyx_n_s_allowaddcons +#define __pyx_n_s_allowlocal __pyx_mstate_global->__pyx_n_s_allowlocal +#define __pyx_n_s_append __pyx_mstate_global->__pyx_n_s_append +#define __pyx_n_s_appendVarSOS1 __pyx_mstate_global->__pyx_n_s_appendVarSOS1 +#define __pyx_n_s_appendVarSOS2 __pyx_mstate_global->__pyx_n_s_appendVarSOS2 +#define __pyx_n_s_applyCutsProbing __pyx_mstate_global->__pyx_n_s_applyCutsProbing +#define __pyx_n_s_args __pyx_mstate_global->__pyx_n_s_args +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_attr __pyx_mstate_global->__pyx_n_s_attr +#define __pyx_n_s_auxvar __pyx_mstate_global->__pyx_n_s_auxvar +#define __pyx_n_s_auxvar_2 __pyx_mstate_global->__pyx_n_s_auxvar_2 +#define __pyx_n_u_auxviol __pyx_mstate_global->__pyx_n_u_auxviol +#define __pyx_n_s_backtrackProbing __pyx_mstate_global->__pyx_n_s_backtrackProbing +#define __pyx_n_u_basic __pyx_mstate_global->__pyx_n_u_basic +#define __pyx_n_s_bdtype __pyx_mstate_global->__pyx_n_s_bdtype +#define __pyx_n_s_beg __pyx_mstate_global->__pyx_n_s_beg +#define __pyx_n_s_benders __pyx_mstate_global->__pyx_n_s_benders +#define __pyx_n_s_benders_2 __pyx_mstate_global->__pyx_n_s_benders_2 +#define __pyx_n_s_benderscreatesub __pyx_mstate_global->__pyx_n_s_benderscreatesub +#define __pyx_n_s_benderscut __pyx_mstate_global->__pyx_n_s_benderscut +#define __pyx_n_s_benderscutexec __pyx_mstate_global->__pyx_n_s_benderscutexec +#define __pyx_n_s_benderscutexit __pyx_mstate_global->__pyx_n_s_benderscutexit +#define __pyx_n_s_benderscutexitsol __pyx_mstate_global->__pyx_n_s_benderscutexitsol +#define __pyx_n_s_benderscutfree __pyx_mstate_global->__pyx_n_s_benderscutfree +#define __pyx_n_s_benderscutinit __pyx_mstate_global->__pyx_n_s_benderscutinit +#define __pyx_n_s_benderscutinitsol __pyx_mstate_global->__pyx_n_s_benderscutinitsol +#define __pyx_n_s_bendersexit __pyx_mstate_global->__pyx_n_s_bendersexit +#define __pyx_n_s_bendersexitpre __pyx_mstate_global->__pyx_n_s_bendersexitpre +#define __pyx_n_s_bendersexitsol __pyx_mstate_global->__pyx_n_s_bendersexitsol +#define __pyx_n_s_bendersfree __pyx_mstate_global->__pyx_n_s_bendersfree +#define __pyx_n_s_bendersfreesub __pyx_mstate_global->__pyx_n_s_bendersfreesub +#define __pyx_n_s_bendersgetvar __pyx_mstate_global->__pyx_n_s_bendersgetvar +#define __pyx_n_s_bendersinit __pyx_mstate_global->__pyx_n_s_bendersinit +#define __pyx_n_s_bendersinitpre __pyx_mstate_global->__pyx_n_s_bendersinitpre +#define __pyx_n_s_bendersinitsol __pyx_mstate_global->__pyx_n_s_bendersinitsol +#define __pyx_n_s_benderspostsolve __pyx_mstate_global->__pyx_n_s_benderspostsolve +#define __pyx_n_s_benderspresubsolve __pyx_mstate_global->__pyx_n_s_benderspresubsolve +#define __pyx_n_s_benderssolvesub __pyx_mstate_global->__pyx_n_s_benderssolvesub +#define __pyx_n_s_benderssolvesubconvex __pyx_mstate_global->__pyx_n_s_benderssolvesubconvex +#define __pyx_n_u_bestsollimit __pyx_mstate_global->__pyx_n_u_bestsollimit +#define __pyx_n_s_bilincoef __pyx_mstate_global->__pyx_n_s_bilincoef +#define __pyx_n_s_bilinterm1 __pyx_mstate_global->__pyx_n_s_bilinterm1 +#define __pyx_n_s_bilinterm2 __pyx_mstate_global->__pyx_n_s_bilinterm2 +#define __pyx_n_s_bilinterms __pyx_mstate_global->__pyx_n_s_bilinterms +#define __pyx_n_s_binVar __pyx_mstate_global->__pyx_n_s_binVar +#define __pyx_n_s_binds __pyx_mstate_global->__pyx_n_s_binds +#define __pyx_n_s_binvar __pyx_mstate_global->__pyx_n_s_binvar +#define __pyx_n_s_binvars __pyx_mstate_global->__pyx_n_s_binvars +#define __pyx_n_s_both __pyx_mstate_global->__pyx_n_s_both +#define __pyx_n_s_boundconstraint __pyx_mstate_global->__pyx_n_s_boundconstraint +#define __pyx_n_s_bounded __pyx_mstate_global->__pyx_n_s_bounded +#define __pyx_n_s_boundtypes __pyx_mstate_global->__pyx_n_s_boundtypes +#define __pyx_n_s_branchVar __pyx_mstate_global->__pyx_n_s_branchVar +#define __pyx_n_s_branchVarVal __pyx_mstate_global->__pyx_n_s_branchVarVal +#define __pyx_n_s_branchbounds __pyx_mstate_global->__pyx_n_s_branchbounds +#define __pyx_n_s_branchdir __pyx_mstate_global->__pyx_n_s_branchdir +#define __pyx_n_s_branchexecext __pyx_mstate_global->__pyx_n_s_branchexecext +#define __pyx_kp_u_branchexecext_is_a_fundamental_c __pyx_mstate_global->__pyx_kp_u_branchexecext_is_a_fundamental_c +#define __pyx_n_s_branchexeclp __pyx_mstate_global->__pyx_n_s_branchexeclp +#define __pyx_kp_u_branchexeclp_is_a_fundamental_ca __pyx_mstate_global->__pyx_kp_u_branchexeclp_is_a_fundamental_ca +#define __pyx_n_s_branchexecps __pyx_mstate_global->__pyx_n_s_branchexecps +#define __pyx_kp_u_branchexecps_is_a_fundamental_ca __pyx_mstate_global->__pyx_kp_u_branchexecps_is_a_fundamental_ca +#define __pyx_n_s_branchexit __pyx_mstate_global->__pyx_n_s_branchexit +#define __pyx_n_s_branchexitsol __pyx_mstate_global->__pyx_n_s_branchexitsol +#define __pyx_n_s_branchfree __pyx_mstate_global->__pyx_n_s_branchfree +#define __pyx_n_s_branchinit __pyx_mstate_global->__pyx_n_s_branchinit +#define __pyx_n_s_branchinitsol __pyx_mstate_global->__pyx_n_s_branchinitsol +#define __pyx_n_s_branchrule __pyx_mstate_global->__pyx_n_s_branchrule +#define __pyx_n_s_branchvars __pyx_mstate_global->__pyx_n_s_branchvars +#define __pyx_n_s_buildGenExprObj __pyx_mstate_global->__pyx_n_s_buildGenExprObj +#define __pyx_n_s_c __pyx_mstate_global->__pyx_n_s_c +#define __pyx_n_u_c __pyx_mstate_global->__pyx_n_u_c +#define __pyx_n_s_c_beg __pyx_mstate_global->__pyx_n_s_c_beg +#define __pyx_n_s_c_binds __pyx_mstate_global->__pyx_n_s_c_binds +#define __pyx_n_s_c_coefs __pyx_mstate_global->__pyx_n_s_c_coefs +#define __pyx_n_s_c_col __pyx_mstate_global->__pyx_n_s_c_col +#define __pyx_n_s_c_dualsol __pyx_mstate_global->__pyx_n_s_c_dualsol +#define __pyx_n_s_c_inds __pyx_mstate_global->__pyx_n_s_c_inds +#define __pyx_n_s_c_lb __pyx_mstate_global->__pyx_n_s_c_lb +#define __pyx_n_s_c_lbs __pyx_mstate_global->__pyx_n_s_c_lbs +#define __pyx_n_s_c_lhs __pyx_mstate_global->__pyx_n_s_c_lhs +#define __pyx_n_s_c_lhss __pyx_mstate_global->__pyx_n_s_c_lhss +#define __pyx_n_s_c_obj __pyx_mstate_global->__pyx_n_s_c_obj +#define __pyx_n_s_c_objs __pyx_mstate_global->__pyx_n_s_c_objs +#define __pyx_n_s_c_path __pyx_mstate_global->__pyx_n_s_c_path +#define __pyx_n_s_c_primalsol __pyx_mstate_global->__pyx_n_s_c_primalsol +#define __pyx_n_s_c_ray __pyx_mstate_global->__pyx_n_s_c_ray +#define __pyx_n_s_c_redcost __pyx_mstate_global->__pyx_n_s_c_redcost +#define __pyx_n_s_c_rhs __pyx_mstate_global->__pyx_n_s_c_rhs +#define __pyx_n_s_c_rhss __pyx_mstate_global->__pyx_n_s_c_rhss +#define __pyx_n_s_c_row __pyx_mstate_global->__pyx_n_s_c_row +#define __pyx_n_s_c_ub __pyx_mstate_global->__pyx_n_s_c_ub +#define __pyx_n_s_c_ubs __pyx_mstate_global->__pyx_n_s_c_ubs +#define __pyx_n_s_cacheRowExtensions __pyx_mstate_global->__pyx_n_s_cacheRowExtensions +#define __pyx_n_s_calcChildEstimate __pyx_mstate_global->__pyx_n_s_calcChildEstimate +#define __pyx_n_s_calcNodeselPriority __pyx_mstate_global->__pyx_n_s_calcNodeselPriority +#define __pyx_kp_u_can_only_be_called_with_a_valid __pyx_mstate_global->__pyx_kp_u_can_only_be_called_with_a_valid +#define __pyx_kp_u_cannot_create_BoundChange_with_S __pyx_mstate_global->__pyx_kp_u_cannot_create_BoundChange_with_S +#define __pyx_kp_u_cannot_create_Column_with_SCIP_C __pyx_mstate_global->__pyx_kp_u_cannot_create_Column_with_SCIP_C +#define __pyx_kp_u_cannot_create_Constraint_with_SC __pyx_mstate_global->__pyx_kp_u_cannot_create_Constraint_with_SC +#define __pyx_kp_u_cannot_create_DomainChanges_with __pyx_mstate_global->__pyx_kp_u_cannot_create_DomainChanges_with +#define __pyx_kp_u_cannot_create_Event_with_SCIP_EV __pyx_mstate_global->__pyx_kp_u_cannot_create_Event_with_SCIP_EV +#define __pyx_kp_u_cannot_create_Model_with_SCIP_NU __pyx_mstate_global->__pyx_kp_u_cannot_create_Model_with_SCIP_NU +#define __pyx_kp_u_cannot_create_NLRow_with_SCIP_NL __pyx_mstate_global->__pyx_kp_u_cannot_create_NLRow_with_SCIP_NL +#define __pyx_kp_u_cannot_create_Row_with_SCIP_ROW __pyx_mstate_global->__pyx_kp_u_cannot_create_Row_with_SCIP_ROW +#define __pyx_kp_u_cannot_create_Solution_with_SCIP __pyx_mstate_global->__pyx_kp_u_cannot_create_Solution_with_SCIP +#define __pyx_kp_u_cannot_create_Variable_with_SCIP __pyx_mstate_global->__pyx_kp_u_cannot_create_Variable_with_SCIP +#define __pyx_kp_u_cannot_divide_by_0 __pyx_mstate_global->__pyx_kp_u_cannot_divide_by_0 +#define __pyx_n_s_capsule __pyx_mstate_global->__pyx_n_s_capsule +#define __pyx_n_s_cardval __pyx_mstate_global->__pyx_n_s_cardval +#define __pyx_n_s_catchEvent __pyx_mstate_global->__pyx_n_s_catchEvent +#define __pyx_n_s_catchRowEvent __pyx_mstate_global->__pyx_n_s_catchRowEvent +#define __pyx_n_s_catchVarEvent __pyx_mstate_global->__pyx_n_s_catchVarEvent +#define __pyx_n_s_category __pyx_mstate_global->__pyx_n_s_category +#define __pyx_n_s_cfile __pyx_mstate_global->__pyx_n_s_cfile +#define __pyx_n_s_chckpriority __pyx_mstate_global->__pyx_n_s_chckpriority +#define __pyx_n_s_check __pyx_mstate_global->__pyx_n_s_check +#define __pyx_n_u_check __pyx_mstate_global->__pyx_n_u_check +#define __pyx_n_s_checkBendersSubproblemOptimality __pyx_mstate_global->__pyx_n_s_checkBendersSubproblemOptimality +#define __pyx_n_s_checkQuadraticNonlinear __pyx_mstate_global->__pyx_n_s_checkQuadraticNonlinear +#define __pyx_n_s_checkSol __pyx_mstate_global->__pyx_n_s_checkSol +#define __pyx_n_s_checkStage __pyx_mstate_global->__pyx_n_s_checkStage +#define __pyx_n_s_checkbounds __pyx_mstate_global->__pyx_n_s_checkbounds +#define __pyx_n_s_checkint __pyx_mstate_global->__pyx_n_s_checkint +#define __pyx_n_s_checkintegrality __pyx_mstate_global->__pyx_n_s_checkintegrality +#define __pyx_n_s_checklprows __pyx_mstate_global->__pyx_n_s_checklprows +#define __pyx_n_s_checktype __pyx_mstate_global->__pyx_n_s_checktype +#define __pyx_n_s_chgBound __pyx_mstate_global->__pyx_n_s_chgBound +#define __pyx_n_s_chgCoef __pyx_mstate_global->__pyx_n_s_chgCoef +#define __pyx_n_s_chgCoefLinear __pyx_mstate_global->__pyx_n_s_chgCoefLinear +#define __pyx_n_s_chgLhs __pyx_mstate_global->__pyx_n_s_chgLhs +#define __pyx_n_s_chgObj __pyx_mstate_global->__pyx_n_s_chgObj +#define __pyx_n_s_chgReoptObjective __pyx_mstate_global->__pyx_n_s_chgReoptObjective +#define __pyx_n_s_chgRhs __pyx_mstate_global->__pyx_n_s_chgRhs +#define __pyx_n_s_chgRowLhsDive __pyx_mstate_global->__pyx_n_s_chgRowLhsDive +#define __pyx_n_s_chgRowRhsDive __pyx_mstate_global->__pyx_n_s_chgRowRhsDive +#define __pyx_n_s_chgSide __pyx_mstate_global->__pyx_n_s_chgSide +#define __pyx_n_s_chgVarBranchPriority __pyx_mstate_global->__pyx_n_s_chgVarBranchPriority +#define __pyx_n_s_chgVarLb __pyx_mstate_global->__pyx_n_s_chgVarLb +#define __pyx_n_s_chgVarLbDive __pyx_mstate_global->__pyx_n_s_chgVarLbDive +#define __pyx_n_s_chgVarLbGlobal __pyx_mstate_global->__pyx_n_s_chgVarLbGlobal +#define __pyx_n_s_chgVarLbNode __pyx_mstate_global->__pyx_n_s_chgVarLbNode +#define __pyx_n_s_chgVarLbProbing __pyx_mstate_global->__pyx_n_s_chgVarLbProbing +#define __pyx_n_s_chgVarObjDive __pyx_mstate_global->__pyx_n_s_chgVarObjDive +#define __pyx_n_s_chgVarObjProbing __pyx_mstate_global->__pyx_n_s_chgVarObjProbing +#define __pyx_n_s_chgVarType __pyx_mstate_global->__pyx_n_s_chgVarType +#define __pyx_n_s_chgVarUb __pyx_mstate_global->__pyx_n_s_chgVarUb +#define __pyx_n_s_chgVarUbDive __pyx_mstate_global->__pyx_n_s_chgVarUbDive +#define __pyx_n_s_chgVarUbGlobal __pyx_mstate_global->__pyx_n_s_chgVarUbGlobal +#define __pyx_n_s_chgVarUbNode __pyx_mstate_global->__pyx_n_s_chgVarUbNode +#define __pyx_n_s_chgVarUbProbing __pyx_mstate_global->__pyx_n_s_chgVarUbProbing +#define __pyx_n_s_child __pyx_mstate_global->__pyx_n_s_child +#define __pyx_n_s_children __pyx_mstate_global->__pyx_n_s_children +#define __pyx_n_s_children_2 __pyx_mstate_global->__pyx_n_s_children_2 +#define __pyx_n_s_childrenexpr __pyx_mstate_global->__pyx_n_s_childrenexpr +#define __pyx_n_s_chr __pyx_mstate_global->__pyx_n_s_chr +#define __pyx_kp_u_cip __pyx_mstate_global->__pyx_kp_u_cip +#define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class +#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem +#define __pyx_n_s_clear __pyx_mstate_global->__pyx_n_s_clear +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close +#define __pyx_n_s_closefd __pyx_mstate_global->__pyx_n_s_closefd +#define __pyx_n_s_cname __pyx_mstate_global->__pyx_n_s_cname +#define __pyx_n_s_coef __pyx_mstate_global->__pyx_n_s_coef +#define __pyx_n_s_coeff __pyx_mstate_global->__pyx_n_s_coeff +#define __pyx_kp_u_coefficients_not_available_for_c __pyx_mstate_global->__pyx_kp_u_coefficients_not_available_for_c +#define __pyx_n_s_coeffs __pyx_mstate_global->__pyx_n_s_coeffs +#define __pyx_n_s_coeffs_2 __pyx_mstate_global->__pyx_n_s_coeffs_2 +#define __pyx_n_s_coeffs_array __pyx_mstate_global->__pyx_n_s_coeffs_array +#define __pyx_n_s_coefs __pyx_mstate_global->__pyx_n_s_coefs +#define __pyx_n_s_col __pyx_mstate_global->__pyx_n_s_col +#define __pyx_n_s_collections_abc __pyx_mstate_global->__pyx_n_s_collections_abc +#define __pyx_n_s_cols __pyx_mstate_global->__pyx_n_s_cols +#define __pyx_n_s_comments __pyx_mstate_global->__pyx_n_s_comments +#define __pyx_n_s_completely __pyx_mstate_global->__pyx_n_s_completely +#define __pyx_n_s_computeBestSolSubproblems __pyx_mstate_global->__pyx_n_s_computeBestSolSubproblems +#define __pyx_n_s_confvar __pyx_mstate_global->__pyx_n_s_confvar +#define __pyx_n_s_cons __pyx_mstate_global->__pyx_n_s_cons +#define __pyx_n_s_consactive __pyx_mstate_global->__pyx_n_s_consactive +#define __pyx_n_s_conscheck __pyx_mstate_global->__pyx_n_s_conscheck +#define __pyx_n_s_conscopy __pyx_mstate_global->__pyx_n_s_conscopy +#define __pyx_n_s_consdeactive __pyx_mstate_global->__pyx_n_s_consdeactive +#define __pyx_n_s_consdelete __pyx_mstate_global->__pyx_n_s_consdelete +#define __pyx_n_s_consdelvars __pyx_mstate_global->__pyx_n_s_consdelvars +#define __pyx_n_s_consdisable __pyx_mstate_global->__pyx_n_s_consdisable +#define __pyx_n_s_consenable __pyx_mstate_global->__pyx_n_s_consenable +#define __pyx_n_s_consenfolp __pyx_mstate_global->__pyx_n_s_consenfolp +#define __pyx_n_s_consenfops __pyx_mstate_global->__pyx_n_s_consenfops +#define __pyx_n_s_consenforelax __pyx_mstate_global->__pyx_n_s_consenforelax +#define __pyx_n_s_consexit __pyx_mstate_global->__pyx_n_s_consexit +#define __pyx_n_s_consexitpre __pyx_mstate_global->__pyx_n_s_consexitpre +#define __pyx_n_s_consexitsol __pyx_mstate_global->__pyx_n_s_consexitsol +#define __pyx_n_s_consfree __pyx_mstate_global->__pyx_n_s_consfree +#define __pyx_n_s_consgetdivebdchgs __pyx_mstate_global->__pyx_n_s_consgetdivebdchgs +#define __pyx_n_s_consgetnvars __pyx_mstate_global->__pyx_n_s_consgetnvars +#define __pyx_n_s_consgetpermsymgraph __pyx_mstate_global->__pyx_n_s_consgetpermsymgraph +#define __pyx_n_s_consgetsignedpermsymgraph __pyx_mstate_global->__pyx_n_s_consgetsignedpermsymgraph +#define __pyx_n_s_consgetvars __pyx_mstate_global->__pyx_n_s_consgetvars +#define __pyx_n_s_conshdlr __pyx_mstate_global->__pyx_n_s_conshdlr +#define __pyx_n_s_conshdrlname __pyx_mstate_global->__pyx_n_s_conshdrlname +#define __pyx_n_s_consinit __pyx_mstate_global->__pyx_n_s_consinit +#define __pyx_n_s_consinitlp __pyx_mstate_global->__pyx_n_s_consinitlp +#define __pyx_n_s_consinitpre __pyx_mstate_global->__pyx_n_s_consinitpre +#define __pyx_n_s_consinitsol __pyx_mstate_global->__pyx_n_s_consinitsol +#define __pyx_n_s_conslock __pyx_mstate_global->__pyx_n_s_conslock +#define __pyx_n_s_consparse __pyx_mstate_global->__pyx_n_s_consparse +#define __pyx_n_s_conspresol __pyx_mstate_global->__pyx_n_s_conspresol +#define __pyx_n_s_consprint __pyx_mstate_global->__pyx_n_s_consprint +#define __pyx_n_s_consprop __pyx_mstate_global->__pyx_n_s_consprop +#define __pyx_n_s_consresprop __pyx_mstate_global->__pyx_n_s_consresprop +#define __pyx_n_s_conss __pyx_mstate_global->__pyx_n_s_conss +#define __pyx_n_s_conss_2 __pyx_mstate_global->__pyx_n_s_conss_2 +#define __pyx_n_s_conssepalp __pyx_mstate_global->__pyx_n_s_conssepalp +#define __pyx_n_s_conssepasol __pyx_mstate_global->__pyx_n_s_conssepasol +#define __pyx_n_s_const __pyx_mstate_global->__pyx_n_s_const +#define __pyx_n_u_const __pyx_mstate_global->__pyx_n_u_const +#define __pyx_n_s_constant __pyx_mstate_global->__pyx_n_s_constant +#define __pyx_n_s_constraint __pyx_mstate_global->__pyx_n_s_constraint +#define __pyx_kp_u_constraint_is_not_nonlinear __pyx_mstate_global->__pyx_kp_u_constraint_is_not_nonlinear +#define __pyx_kp_u_constraint_is_not_quadratic __pyx_mstate_global->__pyx_kp_u_constraint_is_not_quadratic +#define __pyx_n_s_constraints __pyx_mstate_global->__pyx_n_s_constraints +#define __pyx_kp_u_constraints_benders_active __pyx_mstate_global->__pyx_kp_u_constraints_benders_active +#define __pyx_kp_u_constraints_benderslp_active __pyx_mstate_global->__pyx_kp_u_constraints_benderslp_active +#define __pyx_n_s_constrans __pyx_mstate_global->__pyx_n_s_constrans +#define __pyx_n_s_constructLP __pyx_mstate_global->__pyx_n_s_constructLP +#define __pyx_n_s_constype __pyx_mstate_global->__pyx_n_s_constype +#define __pyx_n_s_consvars __pyx_mstate_global->__pyx_n_s_consvars +#define __pyx_n_s_contvars __pyx_mstate_global->__pyx_n_s_contvars +#define __pyx_n_s_copy __pyx_mstate_global->__pyx_n_s_copy +#define __pyx_n_s_cos __pyx_mstate_global->__pyx_n_s_cos +#define __pyx_n_u_cos __pyx_mstate_global->__pyx_n_u_cos +#define __pyx_kp_u_could_not_change_variable_type_o __pyx_mstate_global->__pyx_kp_u_could_not_change_variable_type_o +#define __pyx_n_s_count __pyx_mstate_global->__pyx_n_s_count +#define __pyx_n_s_createChild __pyx_mstate_global->__pyx_n_s_createChild +#define __pyx_n_s_createCons __pyx_mstate_global->__pyx_n_s_createCons +#define __pyx_n_s_createConsFromExpr __pyx_mstate_global->__pyx_n_s_createConsFromExpr +#define __pyx_n_s_createConsGenNonlinear __pyx_mstate_global->__pyx_n_s_createConsGenNonlinear +#define __pyx_n_s_createConsLinear __pyx_mstate_global->__pyx_n_s_createConsLinear +#define __pyx_n_s_createConsNonlinear __pyx_mstate_global->__pyx_n_s_createConsNonlinear +#define __pyx_n_s_createConsQuadratic __pyx_mstate_global->__pyx_n_s_createConsQuadratic +#define __pyx_n_s_createEmptyRowSepa __pyx_mstate_global->__pyx_n_s_createEmptyRowSepa +#define __pyx_n_s_createEmptyRowUnspec __pyx_mstate_global->__pyx_n_s_createEmptyRowUnspec +#define __pyx_n_s_createOrigSol __pyx_mstate_global->__pyx_n_s_createOrigSol +#define __pyx_n_s_createPartialSol __pyx_mstate_global->__pyx_n_s_createPartialSol +#define __pyx_n_s_createProbBasic __pyx_mstate_global->__pyx_n_s_createProbBasic +#define __pyx_n_s_createSol __pyx_mstate_global->__pyx_n_s_createSol +#define __pyx_n_s_createscip __pyx_mstate_global->__pyx_n_s_createscip +#define __pyx_n_s_cut __pyx_mstate_global->__pyx_n_s_cut +#define __pyx_n_s_cutlp __pyx_mstate_global->__pyx_n_s_cutlp +#define __pyx_n_s_cutoff __pyx_mstate_global->__pyx_n_s_cutoff +#define __pyx_n_s_cutpseudo __pyx_mstate_global->__pyx_n_s_cutpseudo +#define __pyx_n_s_cutrelax __pyx_mstate_global->__pyx_n_s_cutrelax +#define __pyx_n_s_cuts __pyx_mstate_global->__pyx_n_s_cuts +#define __pyx_n_u_cuts __pyx_mstate_global->__pyx_n_u_cuts +#define __pyx_n_s_cutsel __pyx_mstate_global->__pyx_n_s_cutsel +#define __pyx_n_s_cutselexit __pyx_mstate_global->__pyx_n_s_cutselexit +#define __pyx_n_s_cutselexitsol __pyx_mstate_global->__pyx_n_s_cutselexitsol +#define __pyx_n_s_cutselfree __pyx_mstate_global->__pyx_n_s_cutselfree +#define __pyx_n_s_cutselinit __pyx_mstate_global->__pyx_n_s_cutselinit +#define __pyx_n_s_cutselinitsol __pyx_mstate_global->__pyx_n_s_cutselinitsol +#define __pyx_n_s_cutselselect __pyx_mstate_global->__pyx_n_s_cutselselect +#define __pyx_n_s_d __pyx_mstate_global->__pyx_n_s_d +#define __pyx_n_s_defaultPlugins __pyx_mstate_global->__pyx_n_s_defaultPlugins +#define __pyx_n_s_deg __pyx_mstate_global->__pyx_n_s_deg +#define __pyx_n_s_degree __pyx_mstate_global->__pyx_n_s_degree +#define __pyx_n_s_degree_locals_genexpr __pyx_mstate_global->__pyx_n_s_degree_locals_genexpr +#define __pyx_n_s_delCoefLinear __pyx_mstate_global->__pyx_n_s_delCoefLinear +#define __pyx_n_s_delCols __pyx_mstate_global->__pyx_n_s_delCols +#define __pyx_n_s_delCons __pyx_mstate_global->__pyx_n_s_delCons +#define __pyx_n_s_delConsLocal __pyx_mstate_global->__pyx_n_s_delConsLocal +#define __pyx_n_s_delRows __pyx_mstate_global->__pyx_n_s_delRows +#define __pyx_n_s_delVar __pyx_mstate_global->__pyx_n_s_delVar +#define __pyx_n_s_delay __pyx_mstate_global->__pyx_n_s_delay +#define __pyx_n_s_delayed __pyx_mstate_global->__pyx_n_s_delayed +#define __pyx_n_s_delayprop __pyx_mstate_global->__pyx_n_s_delayprop +#define __pyx_n_s_delaysepa __pyx_mstate_global->__pyx_n_s_delaysepa +#define __pyx_n_s_deleted __pyx_mstate_global->__pyx_n_s_deleted +#define __pyx_n_s_des __pyx_mstate_global->__pyx_n_s_des +#define __pyx_n_s_desc __pyx_mstate_global->__pyx_n_s_desc +#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict +#define __pyx_n_s_dict_2 __pyx_mstate_global->__pyx_n_s_dict_2 +#define __pyx_n_s_dis __pyx_mstate_global->__pyx_n_s_dis +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_n_s_disablePropagation __pyx_mstate_global->__pyx_n_s_disablePropagation +#define __pyx_n_s_disj_cons __pyx_mstate_global->__pyx_n_s_disj_cons +#define __pyx_n_s_dispchar __pyx_mstate_global->__pyx_n_s_dispchar +#define __pyx_n_s_div __pyx_mstate_global->__pyx_n_s_div +#define __pyx_n_s_doc __pyx_mstate_global->__pyx_n_s_doc +#define __pyx_n_s_domchg __pyx_mstate_global->__pyx_n_s_domchg +#define __pyx_n_s_downchild __pyx_mstate_global->__pyx_n_s_downchild +#define __pyx_n_s_dropEvent __pyx_mstate_global->__pyx_n_s_dropEvent +#define __pyx_n_s_dropRowEvent __pyx_mstate_global->__pyx_n_s_dropRowEvent +#define __pyx_n_s_dropVarEvent __pyx_mstate_global->__pyx_n_s_dropVarEvent +#define __pyx_n_s_dual __pyx_mstate_global->__pyx_n_s_dual +#define __pyx_kp_u_dual_solution_values_not_availab __pyx_mstate_global->__pyx_kp_u_dual_solution_values_not_availab +#define __pyx_n_u_duallimit __pyx_mstate_global->__pyx_n_u_duallimit +#define __pyx_n_s_dualsol __pyx_mstate_global->__pyx_n_s_dualsol +#define __pyx_n_s_dualsol_2 __pyx_mstate_global->__pyx_n_s_dualsol_2 +#define __pyx_n_s_dummy_boundtypes __pyx_mstate_global->__pyx_n_s_dummy_boundtypes +#define __pyx_n_s_dummy_branchbounds __pyx_mstate_global->__pyx_n_s_dummy_branchbounds +#define __pyx_n_s_dummy_branchvars __pyx_mstate_global->__pyx_n_s_dummy_branchvars +#define __pyx_n_s_dynamic __pyx_mstate_global->__pyx_n_s_dynamic +#define __pyx_n_u_dynamic __pyx_mstate_global->__pyx_n_u_dynamic +#define __pyx_n_s_e __pyx_mstate_global->__pyx_n_s_e +#define __pyx_n_s_eagerfreq __pyx_mstate_global->__pyx_n_s_eagerfreq +#define __pyx_n_s_elem __pyx_mstate_global->__pyx_n_s_elem +#define __pyx_n_s_enable __pyx_mstate_global->__pyx_n_s_enable +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_enableReoptimization __pyx_mstate_global->__pyx_n_s_enableReoptimization +#define __pyx_n_s_enablepricing __pyx_mstate_global->__pyx_n_s_enablepricing +#define __pyx_n_s_endDive __pyx_mstate_global->__pyx_n_s_endDive +#define __pyx_n_s_endProbing __pyx_mstate_global->__pyx_n_s_endProbing +#define __pyx_n_s_enfopriority __pyx_mstate_global->__pyx_n_s_enfopriority +#define __pyx_n_s_enforce __pyx_mstate_global->__pyx_n_s_enforce +#define __pyx_n_u_enforce __pyx_mstate_global->__pyx_n_u_enforce +#define __pyx_n_s_enfotype __pyx_mstate_global->__pyx_n_s_enfotype +#define __pyx_n_s_ensure_iterable __pyx_mstate_global->__pyx_n_s_ensure_iterable +#define __pyx_n_s_enter __pyx_mstate_global->__pyx_n_s_enter +#define __pyx_n_s_entries __pyx_mstate_global->__pyx_n_s_entries +#define __pyx_n_s_entrieslist __pyx_mstate_global->__pyx_n_s_entrieslist +#define __pyx_n_s_entry __pyx_mstate_global->__pyx_n_s_entry +#define __pyx_n_s_enumerate __pyx_mstate_global->__pyx_n_s_enumerate +#define __pyx_n_s_epsilon __pyx_mstate_global->__pyx_n_s_epsilon +#define __pyx_n_s_eq __pyx_mstate_global->__pyx_n_s_eq +#define __pyx_n_s_eqchild __pyx_mstate_global->__pyx_n_s_eqchild +#define __pyx_n_s_error __pyx_mstate_global->__pyx_n_s_error +#define __pyx_n_s_estimate __pyx_mstate_global->__pyx_n_s_estimate +#define __pyx_n_s_evaluate __pyx_mstate_global->__pyx_n_s_evaluate +#define __pyx_n_s_event __pyx_mstate_global->__pyx_n_s_event +#define __pyx_kp_u_event_handler_not_found __pyx_mstate_global->__pyx_kp_u_event_handler_not_found +#define __pyx_n_s_eventcopy __pyx_mstate_global->__pyx_n_s_eventcopy +#define __pyx_n_s_eventdelete __pyx_mstate_global->__pyx_n_s_eventdelete +#define __pyx_n_s_eventexec __pyx_mstate_global->__pyx_n_s_eventexec +#define __pyx_n_s_eventexit __pyx_mstate_global->__pyx_n_s_eventexit +#define __pyx_n_s_eventexitsol __pyx_mstate_global->__pyx_n_s_eventexitsol +#define __pyx_n_s_eventfree __pyx_mstate_global->__pyx_n_s_eventfree +#define __pyx_n_s_eventhdlr __pyx_mstate_global->__pyx_n_s_eventhdlr +#define __pyx_n_s_eventhdlr_2 __pyx_mstate_global->__pyx_n_s_eventhdlr_2 +#define __pyx_n_s_eventinit __pyx_mstate_global->__pyx_n_s_eventinit +#define __pyx_n_s_eventinitsol __pyx_mstate_global->__pyx_n_s_eventinitsol +#define __pyx_n_s_eventtype __pyx_mstate_global->__pyx_n_s_eventtype +#define __pyx_n_s_exact __pyx_mstate_global->__pyx_n_s_exact +#define __pyx_n_s_exit __pyx_mstate_global->__pyx_n_s_exit +#define __pyx_n_s_exp __pyx_mstate_global->__pyx_n_s_exp +#define __pyx_n_u_exp __pyx_mstate_global->__pyx_n_u_exp +#define __pyx_kp_u_expected_inequality_that_has_eit __pyx_mstate_global->__pyx_kp_u_expected_inequality_that_has_eit +#define __pyx_kp_u_expected_linear_inequality_expre __pyx_mstate_global->__pyx_kp_u_expected_linear_inequality_expre +#define __pyx_n_s_expo __pyx_mstate_global->__pyx_n_s_expo +#define __pyx_n_s_exponent __pyx_mstate_global->__pyx_n_s_exponent +#define __pyx_kp_u_exponents_must_be_numbers __pyx_mstate_global->__pyx_kp_u_exponents_must_be_numbers +#define __pyx_n_s_expr __pyx_mstate_global->__pyx_n_s_expr +#define __pyx_n_s_expr_richcmp __pyx_mstate_global->__pyx_n_s_expr_richcmp +#define __pyx_n_s_expr_to_array __pyx_mstate_global->__pyx_n_s_expr_to_array +#define __pyx_n_s_expr_to_nodes __pyx_mstate_global->__pyx_n_s_expr_to_nodes +#define __pyx_n_s_ext __pyx_mstate_global->__pyx_n_s_ext +#define __pyx_n_s_extend __pyx_mstate_global->__pyx_n_s_extend +#define __pyx_n_s_extension __pyx_mstate_global->__pyx_n_s_extension +#define __pyx_n_s_f __pyx_mstate_global->__pyx_n_s_f +#define __pyx_n_s_fabs __pyx_mstate_global->__pyx_n_s_fabs +#define __pyx_kp_u_failed __pyx_mstate_global->__pyx_kp_u_failed +#define __pyx_n_s_fdopen __pyx_mstate_global->__pyx_n_s_fdopen +#define __pyx_n_s_feasFrac __pyx_mstate_global->__pyx_n_s_feasFrac +#define __pyx_n_s_feasibility __pyx_mstate_global->__pyx_n_s_feasibility +#define __pyx_n_s_feasible __pyx_mstate_global->__pyx_n_s_feasible +#define __pyx_n_s_feastol __pyx_mstate_global->__pyx_n_s_feastol +#define __pyx_n_s_file __pyx_mstate_global->__pyx_n_s_file +#define __pyx_n_s_filename __pyx_mstate_global->__pyx_n_s_filename +#define __pyx_n_s_fileno __pyx_mstate_global->__pyx_n_s_fileno +#define __pyx_n_s_firstcol __pyx_mstate_global->__pyx_n_s_firstcol +#define __pyx_n_s_firstrow __pyx_mstate_global->__pyx_n_s_firstrow +#define __pyx_n_s_fixVar __pyx_mstate_global->__pyx_n_s_fixVar +#define __pyx_n_s_fixVarProbing __pyx_mstate_global->__pyx_n_s_fixVarProbing +#define __pyx_n_s_fixed __pyx_mstate_global->__pyx_n_s_fixed +#define __pyx_n_s_fixedval __pyx_mstate_global->__pyx_n_s_fixedval +#define __pyx_n_s_fixedvars __pyx_mstate_global->__pyx_n_s_fixedvars +#define __pyx_n_s_flushRowExtensions __pyx_mstate_global->__pyx_n_s_flushRowExtensions +#define __pyx_n_s_fn __pyx_mstate_global->__pyx_n_s_fn +#define __pyx_n_s_force __pyx_mstate_global->__pyx_n_s_force +#define __pyx_n_s_forcecut __pyx_mstate_global->__pyx_n_s_forcecut +#define __pyx_n_s_forcedcuts __pyx_mstate_global->__pyx_n_s_forcedcuts +#define __pyx_n_s_format __pyx_mstate_global->__pyx_n_s_format +#define __pyx_n_s_frac __pyx_mstate_global->__pyx_n_s_frac +#define __pyx_n_s_free __pyx_mstate_global->__pyx_n_s_free +#define __pyx_n_s_freeBendersSubproblems __pyx_mstate_global->__pyx_n_s_freeBendersSubproblems +#define __pyx_n_s_freeProb __pyx_mstate_global->__pyx_n_s_freeProb +#define __pyx_n_s_freeReoptSolve __pyx_mstate_global->__pyx_n_s_freeReoptSolve +#define __pyx_n_s_freeSol __pyx_mstate_global->__pyx_n_s_freeSol +#define __pyx_n_s_freeTransform __pyx_mstate_global->__pyx_n_s_freeTransform +#define __pyx_n_s_freescip __pyx_mstate_global->__pyx_n_s_freescip +#define __pyx_n_s_freq __pyx_mstate_global->__pyx_n_s_freq +#define __pyx_n_s_freqofs __pyx_mstate_global->__pyx_n_s_freqofs +#define __pyx_n_s_from_ptr __pyx_mstate_global->__pyx_n_s_from_ptr +#define __pyx_n_u_gaplimit __pyx_mstate_global->__pyx_n_u_gaplimit +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_genericnames __pyx_mstate_global->__pyx_n_s_genericnames +#define __pyx_n_s_genexpr __pyx_mstate_global->__pyx_n_s_genexpr +#define __pyx_n_s_get __pyx_mstate_global->__pyx_n_s_get +#define __pyx_n_s_getActivity __pyx_mstate_global->__pyx_n_s_getActivity +#define __pyx_n_s_getAddedConss __pyx_mstate_global->__pyx_n_s_getAddedConss +#define __pyx_n_s_getBasisInds __pyx_mstate_global->__pyx_n_s_getBasisInds +#define __pyx_n_s_getBasisStatus __pyx_mstate_global->__pyx_n_s_getBasisStatus +#define __pyx_n_s_getBendersAuxiliaryVar __pyx_mstate_global->__pyx_n_s_getBendersAuxiliaryVar +#define __pyx_n_s_getBendersSubproblem __pyx_mstate_global->__pyx_n_s_getBendersSubproblem +#define __pyx_n_s_getBendersVar __pyx_mstate_global->__pyx_n_s_getBendersVar +#define __pyx_n_s_getBestChild __pyx_mstate_global->__pyx_n_s_getBestChild +#define __pyx_n_s_getBestLeaf __pyx_mstate_global->__pyx_n_s_getBestLeaf +#define __pyx_n_s_getBestNode __pyx_mstate_global->__pyx_n_s_getBestNode +#define __pyx_n_s_getBestSibling __pyx_mstate_global->__pyx_n_s_getBestSibling +#define __pyx_n_s_getBestSol __pyx_mstate_global->__pyx_n_s_getBestSol +#define __pyx_n_s_getBestboundNode __pyx_mstate_global->__pyx_n_s_getBestboundNode +#define __pyx_n_s_getBoundchgs __pyx_mstate_global->__pyx_n_s_getBoundchgs +#define __pyx_n_s_getBoundchgtype __pyx_mstate_global->__pyx_n_s_getBoundchgtype +#define __pyx_n_s_getBounds __pyx_mstate_global->__pyx_n_s_getBounds +#define __pyx_n_s_getBoundtype __pyx_mstate_global->__pyx_n_s_getBoundtype +#define __pyx_n_s_getCol __pyx_mstate_global->__pyx_n_s_getCol +#define __pyx_n_s_getCols __pyx_mstate_global->__pyx_n_s_getCols +#define __pyx_n_s_getCondition __pyx_mstate_global->__pyx_n_s_getCondition +#define __pyx_n_s_getConsNVars __pyx_mstate_global->__pyx_n_s_getConsNVars +#define __pyx_n_s_getConsOriginConshdlrtype __pyx_mstate_global->__pyx_n_s_getConsOriginConshdlrtype +#define __pyx_n_s_getConsVars __pyx_mstate_global->__pyx_n_s_getConsVars +#define __pyx_n_s_getConshdlrName __pyx_mstate_global->__pyx_n_s_getConshdlrName +#define __pyx_n_s_getConss __pyx_mstate_global->__pyx_n_s_getConss +#define __pyx_n_s_getConstant __pyx_mstate_global->__pyx_n_s_getConstant +#define __pyx_n_s_getCurrentNode __pyx_mstate_global->__pyx_n_s_getCurrentNode +#define __pyx_n_s_getCutEfficacy __pyx_mstate_global->__pyx_n_s_getCutEfficacy +#define __pyx_n_s_getCutLPSolCutoffDistance __pyx_mstate_global->__pyx_n_s_getCutLPSolCutoffDistance +#define __pyx_n_s_getDepth __pyx_mstate_global->__pyx_n_s_getDepth +#define __pyx_n_s_getDomchg __pyx_mstate_global->__pyx_n_s_getDomchg +#define __pyx_n_s_getDual __pyx_mstate_global->__pyx_n_s_getDual +#define __pyx_n_s_getDualMultiplier __pyx_mstate_global->__pyx_n_s_getDualMultiplier +#define __pyx_n_s_getDualRay __pyx_mstate_global->__pyx_n_s_getDualRay +#define __pyx_n_s_getDualSolVal __pyx_mstate_global->__pyx_n_s_getDualSolVal +#define __pyx_n_s_getDualbound __pyx_mstate_global->__pyx_n_s_getDualbound +#define __pyx_n_s_getDualboundRoot __pyx_mstate_global->__pyx_n_s_getDualboundRoot +#define __pyx_n_s_getDualfarkasLinear __pyx_mstate_global->__pyx_n_s_getDualfarkasLinear +#define __pyx_n_s_getDualsol __pyx_mstate_global->__pyx_n_s_getDualsol +#define __pyx_n_s_getDualsolLinear __pyx_mstate_global->__pyx_n_s_getDualsolLinear +#define __pyx_n_s_getEstimate __pyx_mstate_global->__pyx_n_s_getEstimate +#define __pyx_n_s_getEventNames __pyx_mstate_global->__pyx_n_s_getEventNames +#define __pyx_n_s_getGap __pyx_mstate_global->__pyx_n_s_getGap +#define __pyx_n_s_getIndex __pyx_mstate_global->__pyx_n_s_getIndex +#define __pyx_n_s_getLPBInvARow __pyx_mstate_global->__pyx_n_s_getLPBInvARow +#define __pyx_n_s_getLPBInvRow __pyx_mstate_global->__pyx_n_s_getLPBInvRow +#define __pyx_n_s_getLPBasisInd __pyx_mstate_global->__pyx_n_s_getLPBasisInd +#define __pyx_n_s_getLPBranchCands __pyx_mstate_global->__pyx_n_s_getLPBranchCands +#define __pyx_n_s_getLPColsData __pyx_mstate_global->__pyx_n_s_getLPColsData +#define __pyx_n_s_getLPObjVal __pyx_mstate_global->__pyx_n_s_getLPObjVal +#define __pyx_n_s_getLPPos __pyx_mstate_global->__pyx_n_s_getLPPos +#define __pyx_n_s_getLPRowsData __pyx_mstate_global->__pyx_n_s_getLPRowsData +#define __pyx_n_s_getLPSol __pyx_mstate_global->__pyx_n_s_getLPSol +#define __pyx_n_s_getLPSolstat __pyx_mstate_global->__pyx_n_s_getLPSolstat +#define __pyx_n_s_getLb __pyx_mstate_global->__pyx_n_s_getLb +#define __pyx_n_s_getLbGlobal __pyx_mstate_global->__pyx_n_s_getLbGlobal +#define __pyx_n_s_getLbLocal __pyx_mstate_global->__pyx_n_s_getLbLocal +#define __pyx_n_s_getLbOriginal __pyx_mstate_global->__pyx_n_s_getLbOriginal +#define __pyx_n_s_getLhs __pyx_mstate_global->__pyx_n_s_getLhs +#define __pyx_n_s_getLinearTerms __pyx_mstate_global->__pyx_n_s_getLinearTerms +#define __pyx_n_s_getLocalEstimate __pyx_mstate_global->__pyx_n_s_getLocalEstimate +#define __pyx_n_s_getLowerbound __pyx_mstate_global->__pyx_n_s_getLowerbound +#define __pyx_n_s_getNAddedConss __pyx_mstate_global->__pyx_n_s_getNAddedConss +#define __pyx_n_s_getNBestSolsFound __pyx_mstate_global->__pyx_n_s_getNBestSolsFound +#define __pyx_n_s_getNBinVars __pyx_mstate_global->__pyx_n_s_getNBinVars +#define __pyx_n_s_getNChildren __pyx_mstate_global->__pyx_n_s_getNChildren +#define __pyx_n_s_getNConss __pyx_mstate_global->__pyx_n_s_getNConss +#define __pyx_n_s_getNCountedSols __pyx_mstate_global->__pyx_n_s_getNCountedSols +#define __pyx_n_s_getNCuts __pyx_mstate_global->__pyx_n_s_getNCuts +#define __pyx_n_s_getNCutsApplied __pyx_mstate_global->__pyx_n_s_getNCutsApplied +#define __pyx_n_s_getNDomchg __pyx_mstate_global->__pyx_n_s_getNDomchg +#define __pyx_n_s_getNFeasibleLeaves __pyx_mstate_global->__pyx_n_s_getNFeasibleLeaves +#define __pyx_n_s_getNInfeasibleLeaves __pyx_mstate_global->__pyx_n_s_getNInfeasibleLeaves +#define __pyx_n_s_getNIntVars __pyx_mstate_global->__pyx_n_s_getNIntVars +#define __pyx_n_s_getNIterations __pyx_mstate_global->__pyx_n_s_getNIterations +#define __pyx_n_s_getNLPCols __pyx_mstate_global->__pyx_n_s_getNLPCols +#define __pyx_n_s_getNLPIterations __pyx_mstate_global->__pyx_n_s_getNLPIterations +#define __pyx_n_s_getNLPNonz __pyx_mstate_global->__pyx_n_s_getNLPNonz +#define __pyx_n_s_getNLPRows __pyx_mstate_global->__pyx_n_s_getNLPRows +#define __pyx_n_s_getNLPs __pyx_mstate_global->__pyx_n_s_getNLPs +#define __pyx_n_s_getNLeaves __pyx_mstate_global->__pyx_n_s_getNLeaves +#define __pyx_n_s_getNLimSolsFound __pyx_mstate_global->__pyx_n_s_getNLimSolsFound +#define __pyx_n_s_getNNlRows __pyx_mstate_global->__pyx_n_s_getNNlRows +#define __pyx_n_s_getNNodes __pyx_mstate_global->__pyx_n_s_getNNodes +#define __pyx_n_s_getNNonz __pyx_mstate_global->__pyx_n_s_getNNonz +#define __pyx_n_s_getNParentBranchings __pyx_mstate_global->__pyx_n_s_getNParentBranchings +#define __pyx_n_s_getNReaders __pyx_mstate_global->__pyx_n_s_getNReaders +#define __pyx_n_s_getNSepaRounds __pyx_mstate_global->__pyx_n_s_getNSepaRounds +#define __pyx_n_s_getNSiblings __pyx_mstate_global->__pyx_n_s_getNSiblings +#define __pyx_n_s_getNSols __pyx_mstate_global->__pyx_n_s_getNSols +#define __pyx_n_s_getNSolsFound __pyx_mstate_global->__pyx_n_s_getNSolsFound +#define __pyx_n_s_getNTotalNodes __pyx_mstate_global->__pyx_n_s_getNTotalNodes +#define __pyx_n_s_getNVars __pyx_mstate_global->__pyx_n_s_getNVars +#define __pyx_n_s_getName __pyx_mstate_global->__pyx_n_s_getName +#define __pyx_n_s_getNewBound __pyx_mstate_global->__pyx_n_s_getNewBound +#define __pyx_n_s_getNlRowActivityBounds __pyx_mstate_global->__pyx_n_s_getNlRowActivityBounds +#define __pyx_n_s_getNlRowSolActivity __pyx_mstate_global->__pyx_n_s_getNlRowSolActivity +#define __pyx_n_s_getNlRowSolFeasibility __pyx_mstate_global->__pyx_n_s_getNlRowSolFeasibility +#define __pyx_n_s_getNlRows __pyx_mstate_global->__pyx_n_s_getNlRows +#define __pyx_n_s_getNode __pyx_mstate_global->__pyx_n_s_getNode +#define __pyx_n_s_getNorm __pyx_mstate_global->__pyx_n_s_getNorm +#define __pyx_n_s_getNumber __pyx_mstate_global->__pyx_n_s_getNumber +#define __pyx_n_s_getObj __pyx_mstate_global->__pyx_n_s_getObj +#define __pyx_n_s_getObjCoeff __pyx_mstate_global->__pyx_n_s_getObjCoeff +#define __pyx_n_s_getObjVal __pyx_mstate_global->__pyx_n_s_getObjVal +#define __pyx_n_s_getObjective __pyx_mstate_global->__pyx_n_s_getObjective +#define __pyx_n_s_getObjectiveSense __pyx_mstate_global->__pyx_n_s_getObjectiveSense +#define __pyx_n_s_getObjlimit __pyx_mstate_global->__pyx_n_s_getObjlimit +#define __pyx_n_s_getObjoffset __pyx_mstate_global->__pyx_n_s_getObjoffset +#define __pyx_n_s_getOldBound __pyx_mstate_global->__pyx_n_s_getOldBound +#define __pyx_n_s_getOp __pyx_mstate_global->__pyx_n_s_getOp +#define __pyx_n_s_getOpenNodes __pyx_mstate_global->__pyx_n_s_getOpenNodes +#define __pyx_n_s_getOrigintype __pyx_mstate_global->__pyx_n_s_getOrigintype +#define __pyx_n_s_getParam __pyx_mstate_global->__pyx_n_s_getParam +#define __pyx_n_s_getParams __pyx_mstate_global->__pyx_n_s_getParams +#define __pyx_n_s_getParent __pyx_mstate_global->__pyx_n_s_getParent +#define __pyx_n_s_getParentBranchings __pyx_mstate_global->__pyx_n_s_getParentBranchings +#define __pyx_n_s_getPresolvingTime __pyx_mstate_global->__pyx_n_s_getPresolvingTime +#define __pyx_n_s_getPrimal __pyx_mstate_global->__pyx_n_s_getPrimal +#define __pyx_n_s_getPrimalRay __pyx_mstate_global->__pyx_n_s_getPrimalRay +#define __pyx_n_s_getPrimalRayVal __pyx_mstate_global->__pyx_n_s_getPrimalRayVal +#define __pyx_n_s_getPrimalbound __pyx_mstate_global->__pyx_n_s_getPrimalbound +#define __pyx_n_s_getPrimsol __pyx_mstate_global->__pyx_n_s_getPrimsol +#define __pyx_n_s_getProbName __pyx_mstate_global->__pyx_n_s_getProbName +#define __pyx_n_s_getProbingDepth __pyx_mstate_global->__pyx_n_s_getProbingDepth +#define __pyx_n_s_getPseudoBranchCands __pyx_mstate_global->__pyx_n_s_getPseudoBranchCands +#define __pyx_n_s_getReadingTime __pyx_mstate_global->__pyx_n_s_getReadingTime +#define __pyx_n_s_getRedcost __pyx_mstate_global->__pyx_n_s_getRedcost +#define __pyx_n_s_getRhs __pyx_mstate_global->__pyx_n_s_getRhs +#define __pyx_n_s_getRow __pyx_mstate_global->__pyx_n_s_getRow +#define __pyx_n_s_getRowActivity __pyx_mstate_global->__pyx_n_s_getRowActivity +#define __pyx_n_s_getRowDualSol __pyx_mstate_global->__pyx_n_s_getRowDualSol +#define __pyx_n_s_getRowLPActivity __pyx_mstate_global->__pyx_n_s_getRowLPActivity +#define __pyx_n_s_getRowLinear __pyx_mstate_global->__pyx_n_s_getRowLinear +#define __pyx_n_s_getRowNumIntCols __pyx_mstate_global->__pyx_n_s_getRowNumIntCols +#define __pyx_n_s_getRowObjParallelism __pyx_mstate_global->__pyx_n_s_getRowObjParallelism +#define __pyx_n_s_getRowParallelism __pyx_mstate_global->__pyx_n_s_getRowParallelism +#define __pyx_n_s_getSides __pyx_mstate_global->__pyx_n_s_getSides +#define __pyx_n_s_getSlack __pyx_mstate_global->__pyx_n_s_getSlack +#define __pyx_n_s_getSlackVarIndicator __pyx_mstate_global->__pyx_n_s_getSlackVarIndicator +#define __pyx_n_s_getSolObjVal __pyx_mstate_global->__pyx_n_s_getSolObjVal +#define __pyx_n_u_getSolObjVal __pyx_mstate_global->__pyx_n_u_getSolObjVal +#define __pyx_n_s_getSolTime __pyx_mstate_global->__pyx_n_s_getSolTime +#define __pyx_n_s_getSolVal __pyx_mstate_global->__pyx_n_s_getSolVal +#define __pyx_n_s_getSols __pyx_mstate_global->__pyx_n_s_getSols +#define __pyx_n_s_getSolvingTime __pyx_mstate_global->__pyx_n_s_getSolvingTime +#define __pyx_n_s_getStage __pyx_mstate_global->__pyx_n_s_getStage +#define __pyx_n_s_getStageName __pyx_mstate_global->__pyx_n_s_getStageName +#define __pyx_n_s_getStageNames __pyx_mstate_global->__pyx_n_s_getStageNames +#define __pyx_n_s_getStatus __pyx_mstate_global->__pyx_n_s_getStatus +#define __pyx_n_s_getTermsQuadratic __pyx_mstate_global->__pyx_n_s_getTermsQuadratic +#define __pyx_n_s_getTotalTime __pyx_mstate_global->__pyx_n_s_getTotalTime +#define __pyx_n_s_getTransformedCons __pyx_mstate_global->__pyx_n_s_getTransformedCons +#define __pyx_n_s_getTransformedVar __pyx_mstate_global->__pyx_n_s_getTransformedVar +#define __pyx_n_s_getTreesizeEstimation __pyx_mstate_global->__pyx_n_s_getTreesizeEstimation +#define __pyx_n_s_getType __pyx_mstate_global->__pyx_n_s_getType +#define __pyx_n_s_getUb __pyx_mstate_global->__pyx_n_s_getUb +#define __pyx_n_s_getUbGlobal __pyx_mstate_global->__pyx_n_s_getUbGlobal +#define __pyx_n_s_getUbLocal __pyx_mstate_global->__pyx_n_s_getUbLocal +#define __pyx_n_s_getUbOriginal __pyx_mstate_global->__pyx_n_s_getUbOriginal +#define __pyx_n_s_getVal __pyx_mstate_global->__pyx_n_s_getVal +#define __pyx_n_s_getVals __pyx_mstate_global->__pyx_n_s_getVals +#define __pyx_n_s_getValsLinear __pyx_mstate_global->__pyx_n_s_getValsLinear +#define __pyx_n_s_getVar __pyx_mstate_global->__pyx_n_s_getVar +#define __pyx_n_s_getVarDict __pyx_mstate_global->__pyx_n_s_getVarDict +#define __pyx_n_s_getVarLbDive __pyx_mstate_global->__pyx_n_s_getVarLbDive +#define __pyx_n_s_getVarRedcost __pyx_mstate_global->__pyx_n_s_getVarRedcost +#define __pyx_n_s_getVarUbDive __pyx_mstate_global->__pyx_n_s_getVarUbDive +#define __pyx_n_s_getVars __pyx_mstate_global->__pyx_n_s_getVars +#define __pyx_n_s_getitem __pyx_mstate_global->__pyx_n_s_getitem +#define __pyx_n_s_getitem___locals_genexpr __pyx_mstate_global->__pyx_n_s_getitem___locals_genexpr +#define __pyx_n_s_getlocale __pyx_mstate_global->__pyx_n_s_getlocale +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_give_ownership __pyx_mstate_global->__pyx_n_s_give_ownership +#define __pyx_kp_u_given_coefficients_are_neither_E __pyx_mstate_global->__pyx_kp_u_given_coefficients_are_neither_E +#define __pyx_kp_u_given_coefficients_are_not_Expr __pyx_mstate_global->__pyx_kp_u_given_coefficients_are_not_Expr +#define __pyx_kp_u_given_constraint_is_not_ExprCons __pyx_mstate_global->__pyx_kp_u_given_constraint_is_not_ExprCons +#define __pyx_kp_u_given_constraint_is_not_linear_d __pyx_mstate_global->__pyx_kp_u_given_constraint_is_not_linear_d +#define __pyx_kp_u_given_constraint_is_not_quadrati __pyx_mstate_global->__pyx_kp_u_given_constraint_is_not_quadrati +#define __pyx_n_s_globalcopy __pyx_mstate_global->__pyx_n_s_globalcopy +#define __pyx_n_s_hasPrimalRay __pyx_mstate_global->__pyx_n_s_hasPrimalRay +#define __pyx_n_s_hash __pyx_mstate_global->__pyx_n_s_hash +#define __pyx_n_s_hashval __pyx_mstate_global->__pyx_n_s_hashval +#define __pyx_n_u_hashval __pyx_mstate_global->__pyx_n_u_hashval +#define __pyx_n_s_heur __pyx_mstate_global->__pyx_n_s_heur +#define __pyx_n_s_heur_2 __pyx_mstate_global->__pyx_n_s_heur_2 +#define __pyx_n_s_heurexec __pyx_mstate_global->__pyx_n_s_heurexec +#define __pyx_n_s_heurexit __pyx_mstate_global->__pyx_n_s_heurexit +#define __pyx_n_s_heurexitsol __pyx_mstate_global->__pyx_n_s_heurexitsol +#define __pyx_n_s_heurfree __pyx_mstate_global->__pyx_n_s_heurfree +#define __pyx_n_s_heurinit __pyx_mstate_global->__pyx_n_s_heurinit +#define __pyx_n_s_heurinitsol __pyx_mstate_global->__pyx_n_s_heurinitsol +#define __pyx_n_s_heurtiming __pyx_mstate_global->__pyx_n_s_heurtiming +#define __pyx_n_s_hideOutput __pyx_mstate_global->__pyx_n_s_hideOutput +#define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i +#define __pyx_n_s_idx __pyx_mstate_global->__pyx_n_s_idx +#define __pyx_n_s_idxs __pyx_mstate_global->__pyx_n_s_idxs +#define __pyx_n_s_implvars __pyx_mstate_global->__pyx_n_s_implvars +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_inProbing __pyx_mstate_global->__pyx_n_s_inProbing +#define __pyx_n_s_inRepropagation __pyx_mstate_global->__pyx_n_s_inRepropagation +#define __pyx_n_s_includeBenders __pyx_mstate_global->__pyx_n_s_includeBenders +#define __pyx_n_s_includeBendersDefaultCuts __pyx_mstate_global->__pyx_n_s_includeBendersDefaultCuts +#define __pyx_n_s_includeBenderscut __pyx_mstate_global->__pyx_n_s_includeBenderscut +#define __pyx_n_s_includeBranchrule __pyx_mstate_global->__pyx_n_s_includeBranchrule +#define __pyx_n_s_includeConshdlr __pyx_mstate_global->__pyx_n_s_includeConshdlr +#define __pyx_n_s_includeCutsel __pyx_mstate_global->__pyx_n_s_includeCutsel +#define __pyx_n_s_includeDefaultPlugins __pyx_mstate_global->__pyx_n_s_includeDefaultPlugins +#define __pyx_n_s_includeEventhdlr __pyx_mstate_global->__pyx_n_s_includeEventhdlr +#define __pyx_n_s_includeHeur __pyx_mstate_global->__pyx_n_s_includeHeur +#define __pyx_n_s_includeNodesel __pyx_mstate_global->__pyx_n_s_includeNodesel +#define __pyx_n_s_includePresol __pyx_mstate_global->__pyx_n_s_includePresol +#define __pyx_n_s_includePricer __pyx_mstate_global->__pyx_n_s_includePricer +#define __pyx_n_s_includeProp __pyx_mstate_global->__pyx_n_s_includeProp +#define __pyx_n_s_includeReader __pyx_mstate_global->__pyx_n_s_includeReader +#define __pyx_n_s_includeRelax __pyx_mstate_global->__pyx_n_s_includeRelax +#define __pyx_n_s_includeSepa __pyx_mstate_global->__pyx_n_s_includeSepa +#define __pyx_n_s_indices __pyx_mstate_global->__pyx_n_s_indices +#define __pyx_n_s_inds __pyx_mstate_global->__pyx_n_s_inds +#define __pyx_n_s_indvar __pyx_mstate_global->__pyx_n_s_indvar +#define __pyx_n_s_indvars __pyx_mstate_global->__pyx_n_s_indvars +#define __pyx_n_u_inf __pyx_mstate_global->__pyx_n_u_inf +#define __pyx_n_s_infeasible __pyx_mstate_global->__pyx_n_s_infeasible +#define __pyx_n_u_infeasible __pyx_mstate_global->__pyx_n_u_infeasible +#define __pyx_n_s_infeasible_2 __pyx_mstate_global->__pyx_n_s_infeasible_2 +#define __pyx_n_s_inferinfo __pyx_mstate_global->__pyx_n_s_inferinfo +#define __pyx_n_s_infinity __pyx_mstate_global->__pyx_n_s_infinity +#define __pyx_n_u_inforunbd __pyx_mstate_global->__pyx_n_u_inforunbd +#define __pyx_n_s_init __pyx_mstate_global->__pyx_n_s_init +#define __pyx_n_s_initBendersDefault __pyx_mstate_global->__pyx_n_s_initBendersDefault +#define __pyx_n_s_init_subclass __pyx_mstate_global->__pyx_n_s_init_subclass +#define __pyx_n_s_initial __pyx_mstate_global->__pyx_n_s_initial +#define __pyx_n_u_initial __pyx_mstate_global->__pyx_n_u_initial +#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing +#define __pyx_n_s_interruptSolve __pyx_mstate_global->__pyx_n_s_interruptSolve +#define __pyx_n_s_intvars __pyx_mstate_global->__pyx_n_s_intvars +#define __pyx_n_s_isActive __pyx_mstate_global->__pyx_n_s_isActive +#define __pyx_n_s_isChecked __pyx_mstate_global->__pyx_n_s_isChecked +#define __pyx_n_s_isCutEfficacious __pyx_mstate_global->__pyx_n_s_isCutEfficacious +#define __pyx_n_s_isDualFeasible __pyx_mstate_global->__pyx_n_s_isDualFeasible +#define __pyx_n_s_isDynamic __pyx_mstate_global->__pyx_n_s_isDynamic +#define __pyx_n_s_isEQ __pyx_mstate_global->__pyx_n_s_isEQ +#define __pyx_n_s_isEnforced __pyx_mstate_global->__pyx_n_s_isEnforced +#define __pyx_n_s_isFeasEQ __pyx_mstate_global->__pyx_n_s_isFeasEQ +#define __pyx_n_s_isFeasIntegral __pyx_mstate_global->__pyx_n_s_isFeasIntegral +#define __pyx_n_s_isFeasNegative __pyx_mstate_global->__pyx_n_s_isFeasNegative +#define __pyx_n_s_isFeasZero __pyx_mstate_global->__pyx_n_s_isFeasZero +#define __pyx_n_s_isGE __pyx_mstate_global->__pyx_n_s_isGE +#define __pyx_n_s_isGT __pyx_mstate_global->__pyx_n_s_isGT +#define __pyx_n_s_isInGlobalCutpool __pyx_mstate_global->__pyx_n_s_isInGlobalCutpool +#define __pyx_n_s_isInLP __pyx_mstate_global->__pyx_n_s_isInLP +#define __pyx_n_s_isInfinity __pyx_mstate_global->__pyx_n_s_isInfinity +#define __pyx_n_s_isInitial __pyx_mstate_global->__pyx_n_s_isInitial +#define __pyx_n_s_isIntegral __pyx_mstate_global->__pyx_n_s_isIntegral +#define __pyx_n_s_isLE __pyx_mstate_global->__pyx_n_s_isLE +#define __pyx_n_s_isLPSolBasic __pyx_mstate_global->__pyx_n_s_isLPSolBasic +#define __pyx_n_s_isLT __pyx_mstate_global->__pyx_n_s_isLT +#define __pyx_n_s_isLinear __pyx_mstate_global->__pyx_n_s_isLinear +#define __pyx_n_s_isLocal __pyx_mstate_global->__pyx_n_s_isLocal +#define __pyx_n_s_isModifiable __pyx_mstate_global->__pyx_n_s_isModifiable +#define __pyx_n_s_isNLPConstructed __pyx_mstate_global->__pyx_n_s_isNLPConstructed +#define __pyx_n_s_isNonlinear __pyx_mstate_global->__pyx_n_s_isNonlinear +#define __pyx_n_s_isObjChangedProbing __pyx_mstate_global->__pyx_n_s_isObjChangedProbing +#define __pyx_n_s_isOriginal __pyx_mstate_global->__pyx_n_s_isOriginal +#define __pyx_n_s_isPrimalFeasible __pyx_mstate_global->__pyx_n_s_isPrimalFeasible +#define __pyx_n_s_isPropagated __pyx_mstate_global->__pyx_n_s_isPropagated +#define __pyx_n_s_isPropagatedAgain __pyx_mstate_global->__pyx_n_s_isPropagatedAgain +#define __pyx_n_s_isRedundant __pyx_mstate_global->__pyx_n_s_isRedundant +#define __pyx_n_s_isRemovable __pyx_mstate_global->__pyx_n_s_isRemovable +#define __pyx_n_s_isSeparated __pyx_mstate_global->__pyx_n_s_isSeparated +#define __pyx_n_s_isStickingAtNode __pyx_mstate_global->__pyx_n_s_isStickingAtNode +#define __pyx_n_s_isZero __pyx_mstate_global->__pyx_n_s_isZero +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_n_s_is_integer __pyx_mstate_global->__pyx_n_s_is_integer +#define __pyx_n_s_is_memory_freed __pyx_mstate_global->__pyx_n_s_is_memory_freed +#define __pyx_n_s_is_number __pyx_mstate_global->__pyx_n_s_is_number +#define __pyx_n_s_isconvex __pyx_mstate_global->__pyx_n_s_isconvex +#define __pyx_n_s_isdict __pyx_mstate_global->__pyx_n_s_isdict +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_islpcut __pyx_mstate_global->__pyx_n_s_islpcut +#define __pyx_n_s_isquadratic __pyx_mstate_global->__pyx_n_s_isquadratic +#define __pyx_n_s_items __pyx_mstate_global->__pyx_n_s_items +#define __pyx_n_s_iters __pyx_mstate_global->__pyx_n_s_iters +#define __pyx_n_s_itertools __pyx_mstate_global->__pyx_n_s_itertools +#define __pyx_n_s_itlim __pyx_mstate_global->__pyx_n_s_itlim +#define __pyx_n_s_j __pyx_mstate_global->__pyx_n_s_j +#define __pyx_n_s_key __pyx_mstate_global->__pyx_n_s_key +#define __pyx_n_s_keys __pyx_mstate_global->__pyx_n_s_keys +#define __pyx_n_s_kwargs __pyx_mstate_global->__pyx_n_s_kwargs +#define __pyx_n_s_lambda __pyx_mstate_global->__pyx_n_s_lambda +#define __pyx_n_s_lastcol __pyx_mstate_global->__pyx_n_s_lastcol +#define __pyx_n_s_lastrow __pyx_mstate_global->__pyx_n_s_lastrow +#define __pyx_n_s_lb __pyx_mstate_global->__pyx_n_s_lb +#define __pyx_n_s_lbs __pyx_mstate_global->__pyx_n_s_lbs +#define __pyx_n_s_leaves __pyx_mstate_global->__pyx_n_s_leaves +#define __pyx_n_s_leaves_2 __pyx_mstate_global->__pyx_n_s_leaves_2 +#define __pyx_n_s_len __pyx_mstate_global->__pyx_n_s_len +#define __pyx_n_s_length __pyx_mstate_global->__pyx_n_s_length +#define __pyx_n_s_lhs __pyx_mstate_global->__pyx_n_s_lhs +#define __pyx_n_u_lhs __pyx_mstate_global->__pyx_n_u_lhs +#define __pyx_n_s_lhs_2 __pyx_mstate_global->__pyx_n_s_lhs_2 +#define __pyx_n_s_lhss __pyx_mstate_global->__pyx_n_s_lhss +#define __pyx_n_s_lhsslack __pyx_mstate_global->__pyx_n_s_lhsslack +#define __pyx_n_s_lincoef __pyx_mstate_global->__pyx_n_s_lincoef +#define __pyx_n_s_lincoefs __pyx_mstate_global->__pyx_n_s_lincoefs +#define __pyx_n_s_lincoefs_2 __pyx_mstate_global->__pyx_n_s_lincoefs_2 +#define __pyx_n_s_lincons __pyx_mstate_global->__pyx_n_s_lincons +#define __pyx_n_u_linear __pyx_mstate_global->__pyx_n_u_linear +#define __pyx_n_s_linexprs __pyx_mstate_global->__pyx_n_s_linexprs +#define __pyx_kp_u_linked_SCIP_is_not_compatible_to __pyx_mstate_global->__pyx_kp_u_linked_SCIP_is_not_compatible_to +#define __pyx_kp_u_linked_SCIP_is_not_recommended_f __pyx_mstate_global->__pyx_kp_u_linked_SCIP_is_not_recommended_f +#define __pyx_n_s_linterms __pyx_mstate_global->__pyx_n_s_linterms +#define __pyx_n_s_linvars __pyx_mstate_global->__pyx_n_s_linvars +#define __pyx_n_s_local __pyx_mstate_global->__pyx_n_s_local +#define __pyx_n_u_local __pyx_mstate_global->__pyx_n_u_local +#define __pyx_n_s_locale __pyx_mstate_global->__pyx_n_s_locale +#define __pyx_n_s_locktype __pyx_mstate_global->__pyx_n_s_locktype +#define __pyx_n_s_log __pyx_mstate_global->__pyx_n_s_log +#define __pyx_n_u_log __pyx_mstate_global->__pyx_n_u_log +#define __pyx_n_u_lower __pyx_mstate_global->__pyx_n_u_lower +#define __pyx_n_u_lowerbound __pyx_mstate_global->__pyx_n_u_lowerbound +#define __pyx_n_s_lowerbounds __pyx_mstate_global->__pyx_n_s_lowerbounds +#define __pyx_n_s_lpcands __pyx_mstate_global->__pyx_n_s_lpcands +#define __pyx_n_s_lpcandsfrac __pyx_mstate_global->__pyx_n_s_lpcandsfrac +#define __pyx_n_s_lpcandssol __pyx_mstate_global->__pyx_n_s_lpcandssol +#define __pyx_n_s_lperror __pyx_mstate_global->__pyx_n_s_lperror +#define __pyx_n_s_lpi __pyx_mstate_global->__pyx_n_s_lpi +#define __pyx_n_s_lpiGetIterations __pyx_mstate_global->__pyx_n_s_lpiGetIterations +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_map __pyx_mstate_global->__pyx_n_s_map +#define __pyx_n_s_mappedvar __pyx_mstate_global->__pyx_n_s_mappedvar +#define __pyx_n_u_mappedvar __pyx_mstate_global->__pyx_n_u_mappedvar +#define __pyx_n_s_mappedvar_2 __pyx_mstate_global->__pyx_n_s_mappedvar_2 +#define __pyx_n_s_max __pyx_mstate_global->__pyx_n_s_max +#define __pyx_n_s_maxactivity __pyx_mstate_global->__pyx_n_s_maxactivity +#define __pyx_n_s_maxbounddist __pyx_mstate_global->__pyx_n_s_maxbounddist +#define __pyx_n_s_maxdepth __pyx_mstate_global->__pyx_n_s_maxdepth +#define __pyx_n_u_maximize __pyx_mstate_global->__pyx_n_u_maximize +#define __pyx_n_s_maxnconss __pyx_mstate_global->__pyx_n_s_maxnconss +#define __pyx_n_s_maxnselectedcuts __pyx_mstate_global->__pyx_n_s_maxnselectedcuts +#define __pyx_n_s_maxprerounds __pyx_mstate_global->__pyx_n_s_maxprerounds +#define __pyx_n_s_maxproprounds __pyx_mstate_global->__pyx_n_s_maxproprounds +#define __pyx_n_s_maxrounds __pyx_mstate_global->__pyx_n_s_maxrounds +#define __pyx_n_u_memlimit __pyx_mstate_global->__pyx_n_u_memlimit +#define __pyx_n_s_memsavepriority __pyx_mstate_global->__pyx_n_s_memsavepriority +#define __pyx_n_s_mergecandidates __pyx_mstate_global->__pyx_n_s_mergecandidates +#define __pyx_n_u_merged __pyx_mstate_global->__pyx_n_u_merged +#define __pyx_n_s_metaclass __pyx_mstate_global->__pyx_n_s_metaclass +#define __pyx_n_s_method __pyx_mstate_global->__pyx_n_s_method +#define __pyx_kp_u_method_can_only_be_called_in_sta __pyx_mstate_global->__pyx_kp_u_method_can_only_be_called_in_sta +#define __pyx_kp_u_method_cannot_be_called_before_p __pyx_mstate_global->__pyx_kp_u_method_cannot_be_called_before_p +#define __pyx_kp_u_method_cannot_be_called_for_cons __pyx_mstate_global->__pyx_kp_u_method_cannot_be_called_for_cons +#define __pyx_n_s_minactivity __pyx_mstate_global->__pyx_n_s_minactivity +#define __pyx_n_u_minimize __pyx_mstate_global->__pyx_n_u_minimize +#define __pyx_n_s_minus __pyx_mstate_global->__pyx_n_s_minus +#define __pyx_n_s_model __pyx_mstate_global->__pyx_n_s_model +#define __pyx_n_u_model __pyx_mstate_global->__pyx_n_u_model +#define __pyx_kp_u_model_cip __pyx_mstate_global->__pyx_kp_u_model_cip +#define __pyx_kp_u_model_getDualMultiplier_cons_is __pyx_mstate_global->__pyx_kp_u_model_getDualMultiplier_cons_is +#define __pyx_n_s_modifiable __pyx_mstate_global->__pyx_n_s_modifiable +#define __pyx_n_u_modifiable __pyx_mstate_global->__pyx_n_u_modifiable +#define __pyx_n_s_module __pyx_mstate_global->__pyx_n_s_module +#define __pyx_n_s_monomials __pyx_mstate_global->__pyx_n_s_monomials +#define __pyx_n_s_mul __pyx_mstate_global->__pyx_n_s_mul +#define __pyx_n_s_mul_2 __pyx_mstate_global->__pyx_n_s_mul_2 +#define __pyx_n_s_myMessageHandler __pyx_mstate_global->__pyx_n_s_myMessageHandler +#define __pyx_n_s_n __pyx_mstate_global->__pyx_n_s_n +#define __pyx_n_s_n_conss __pyx_mstate_global->__pyx_n_s_n_conss +#define __pyx_n_u_naddconss __pyx_mstate_global->__pyx_n_u_naddconss +#define __pyx_n_u_naddholes __pyx_mstate_global->__pyx_n_u_naddholes +#define __pyx_n_u_naggrvars __pyx_mstate_global->__pyx_n_u_naggrvars +#define __pyx_n_s_nam __pyx_mstate_global->__pyx_n_s_nam +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_u_name __pyx_mstate_global->__pyx_n_u_name +#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 +#define __pyx_n_s_nbenders __pyx_mstate_global->__pyx_n_s_nbenders +#define __pyx_n_s_nbilinterms __pyx_mstate_global->__pyx_n_s_nbilinterms +#define __pyx_n_s_nboundchgs __pyx_mstate_global->__pyx_n_s_nboundchgs +#define __pyx_n_s_nbranchings __pyx_mstate_global->__pyx_n_s_nbranchings +#define __pyx_n_s_nbranchvars __pyx_mstate_global->__pyx_n_s_nbranchvars +#define __pyx_n_s_ncands __pyx_mstate_global->__pyx_n_s_ncands +#define __pyx_n_u_nchgbds __pyx_mstate_global->__pyx_n_u_nchgbds +#define __pyx_n_u_nchgcoefs __pyx_mstate_global->__pyx_n_u_nchgcoefs +#define __pyx_n_u_nchgsides __pyx_mstate_global->__pyx_n_u_nchgsides +#define __pyx_n_u_nchgvartypes __pyx_mstate_global->__pyx_n_u_nchgvartypes +#define __pyx_n_s_nchildren __pyx_mstate_global->__pyx_n_s_nchildren +#define __pyx_n_s_nchildren_2 __pyx_mstate_global->__pyx_n_s_nchildren_2 +#define __pyx_n_s_ncols __pyx_mstate_global->__pyx_n_s_ncols +#define __pyx_n_s_nconsprop __pyx_mstate_global->__pyx_n_s_nconsprop +#define __pyx_n_s_nconss __pyx_mstate_global->__pyx_n_s_nconss +#define __pyx_n_s_nconss_2 __pyx_mstate_global->__pyx_n_s_nconss_2 +#define __pyx_n_u_ndelconss __pyx_mstate_global->__pyx_n_u_ndelconss +#define __pyx_n_s_ndomredsfound __pyx_mstate_global->__pyx_n_s_ndomredsfound +#define __pyx_n_s_needscons __pyx_mstate_global->__pyx_n_s_needscons +#define __pyx_n_s_negate __pyx_mstate_global->__pyx_n_s_negate +#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new +#define __pyx_n_s_newCheck __pyx_mstate_global->__pyx_n_s_newCheck +#define __pyx_n_s_newEnf __pyx_mstate_global->__pyx_n_s_newEnf +#define __pyx_n_s_newInit __pyx_mstate_global->__pyx_n_s_newInit +#define __pyx_n_s_newProbingNode __pyx_mstate_global->__pyx_n_s_newProbingNode +#define __pyx_n_s_newRem __pyx_mstate_global->__pyx_n_s_newRem +#define __pyx_n_s_newbound __pyx_mstate_global->__pyx_n_s_newbound +#define __pyx_n_s_newlhs __pyx_mstate_global->__pyx_n_s_newlhs +#define __pyx_n_s_newobj __pyx_mstate_global->__pyx_n_s_newobj +#define __pyx_n_s_newrhs __pyx_mstate_global->__pyx_n_s_newrhs +#define __pyx_n_s_newval __pyx_mstate_global->__pyx_n_s_newval +#define __pyx_n_u_nfixedvars __pyx_mstate_global->__pyx_n_u_nfixedvars +#define __pyx_n_s_nfracimplvars __pyx_mstate_global->__pyx_n_s_nfracimplvars +#define __pyx_n_s_niters __pyx_mstate_global->__pyx_n_s_niters +#define __pyx_n_s_nleaves __pyx_mstate_global->__pyx_n_s_nleaves +#define __pyx_n_s_nlinvars __pyx_mstate_global->__pyx_n_s_nlinvars +#define __pyx_n_s_nlinvars_2 __pyx_mstate_global->__pyx_n_s_nlinvars_2 +#define __pyx_n_s_nlocksdown __pyx_mstate_global->__pyx_n_s_nlocksdown +#define __pyx_n_s_nlocksneg __pyx_mstate_global->__pyx_n_s_nlocksneg +#define __pyx_n_s_nlockspos __pyx_mstate_global->__pyx_n_s_nlockspos +#define __pyx_n_s_nlocksup __pyx_mstate_global->__pyx_n_s_nlocksup +#define __pyx_n_s_nlpcands __pyx_mstate_global->__pyx_n_s_nlpcands +#define __pyx_n_s_nlrow __pyx_mstate_global->__pyx_n_s_nlrow +#define __pyx_n_s_nlrows __pyx_mstate_global->__pyx_n_s_nlrows +#define __pyx_n_s_nmarkedconss __pyx_mstate_global->__pyx_n_s_nmarkedconss +#define __pyx_n_s_nnewaddconss __pyx_mstate_global->__pyx_n_s_nnewaddconss +#define __pyx_n_u_nnewaddconss __pyx_mstate_global->__pyx_n_u_nnewaddconss +#define __pyx_n_u_nnewaddholes __pyx_mstate_global->__pyx_n_u_nnewaddholes +#define __pyx_n_s_nnewaggrvars __pyx_mstate_global->__pyx_n_s_nnewaggrvars +#define __pyx_n_u_nnewaggrvars __pyx_mstate_global->__pyx_n_u_nnewaggrvars +#define __pyx_n_s_nnewchgbds __pyx_mstate_global->__pyx_n_s_nnewchgbds +#define __pyx_n_u_nnewchgbds __pyx_mstate_global->__pyx_n_u_nnewchgbds +#define __pyx_n_s_nnewchgcoefs __pyx_mstate_global->__pyx_n_s_nnewchgcoefs +#define __pyx_n_u_nnewchgcoefs __pyx_mstate_global->__pyx_n_u_nnewchgcoefs +#define __pyx_n_s_nnewchgsides __pyx_mstate_global->__pyx_n_s_nnewchgsides +#define __pyx_n_u_nnewchgsides __pyx_mstate_global->__pyx_n_u_nnewchgsides +#define __pyx_n_s_nnewchgvartypes __pyx_mstate_global->__pyx_n_s_nnewchgvartypes +#define __pyx_n_u_nnewchgvartypes __pyx_mstate_global->__pyx_n_u_nnewchgvartypes +#define __pyx_n_s_nnewdelconss __pyx_mstate_global->__pyx_n_s_nnewdelconss +#define __pyx_n_u_nnewdelconss __pyx_mstate_global->__pyx_n_u_nnewdelconss +#define __pyx_n_s_nnewfixedvars __pyx_mstate_global->__pyx_n_s_nnewfixedvars +#define __pyx_n_u_nnewfixedvars __pyx_mstate_global->__pyx_n_u_nnewfixedvars +#define __pyx_n_s_nnewholes __pyx_mstate_global->__pyx_n_s_nnewholes +#define __pyx_n_s_nnewupgdconss __pyx_mstate_global->__pyx_n_s_nnewupgdconss +#define __pyx_n_u_nnewupgdconss __pyx_mstate_global->__pyx_n_u_nnewupgdconss +#define __pyx_n_s_nnonz __pyx_mstate_global->__pyx_n_s_nnonz +#define __pyx_kp_u_no_reduced_cost_available_for_va __pyx_mstate_global->__pyx_kp_u_no_reduced_cost_available_for_va +#define __pyx_n_s_node __pyx_mstate_global->__pyx_n_s_node +#define __pyx_n_s_node1 __pyx_mstate_global->__pyx_n_s_node1 +#define __pyx_n_s_node2 __pyx_mstate_global->__pyx_n_s_node2 +#define __pyx_n_s_nodecomp __pyx_mstate_global->__pyx_n_s_nodecomp +#define __pyx_n_s_nodeexit __pyx_mstate_global->__pyx_n_s_nodeexit +#define __pyx_n_s_nodeexitsol __pyx_mstate_global->__pyx_n_s_nodeexitsol +#define __pyx_n_s_nodefree __pyx_mstate_global->__pyx_n_s_nodefree +#define __pyx_n_s_nodeinfeasible __pyx_mstate_global->__pyx_n_s_nodeinfeasible +#define __pyx_n_s_nodeinit __pyx_mstate_global->__pyx_n_s_nodeinit +#define __pyx_n_s_nodeinitsol __pyx_mstate_global->__pyx_n_s_nodeinitsol +#define __pyx_n_u_nodelimit __pyx_mstate_global->__pyx_n_u_nodelimit +#define __pyx_n_s_nodes __pyx_mstate_global->__pyx_n_s_nodes +#define __pyx_n_s_nodesel __pyx_mstate_global->__pyx_n_s_nodesel +#define __pyx_n_s_nodeselect __pyx_mstate_global->__pyx_n_s_nodeselect +#define __pyx_n_s_nodeselprio __pyx_mstate_global->__pyx_n_s_nodeselprio +#define __pyx_n_u_nonlinear __pyx_mstate_global->__pyx_n_u_nonlinear +#define __pyx_n_s_normalize __pyx_mstate_global->__pyx_n_s_normalize +#define __pyx_n_s_npriolpcands __pyx_mstate_global->__pyx_n_s_npriolpcands +#define __pyx_n_s_npriomergecands __pyx_mstate_global->__pyx_n_s_npriomergecands +#define __pyx_n_s_npriopseudocands __pyx_mstate_global->__pyx_n_s_npriopseudocands +#define __pyx_n_s_nprop __pyx_mstate_global->__pyx_n_s_nprop +#define __pyx_n_s_npseudocands __pyx_mstate_global->__pyx_n_s_npseudocands +#define __pyx_n_s_nquadterms __pyx_mstate_global->__pyx_n_s_nquadterms +#define __pyx_n_s_nrounds __pyx_mstate_global->__pyx_n_s_nrounds +#define __pyx_n_s_nrows __pyx_mstate_global->__pyx_n_s_nrows +#define __pyx_n_u_nselectedcuts __pyx_mstate_global->__pyx_n_u_nselectedcuts +#define __pyx_n_s_nsiblings __pyx_mstate_global->__pyx_n_s_nsiblings +#define __pyx_n_s_nsols __pyx_mstate_global->__pyx_n_s_nsols +#define __pyx_n_s_nsubproblems __pyx_mstate_global->__pyx_n_s_nsubproblems +#define __pyx_n_s_number __pyx_mstate_global->__pyx_n_s_number +#define __pyx_n_u_nupgdconss __pyx_mstate_global->__pyx_n_u_nupgdconss +#define __pyx_n_s_nusefulconss __pyx_mstate_global->__pyx_n_s_nusefulconss +#define __pyx_n_s_nvars __pyx_mstate_global->__pyx_n_s_nvars +#define __pyx_n_u_nvars __pyx_mstate_global->__pyx_n_u_nvars +#define __pyx_n_s_nvars_2 __pyx_mstate_global->__pyx_n_s_nvars_2 +#define __pyx_n_s_obj __pyx_mstate_global->__pyx_n_s_obj +#define __pyx_n_s_objective __pyx_mstate_global->__pyx_n_s_objective +#define __pyx_n_u_objective __pyx_mstate_global->__pyx_n_u_objective +#define __pyx_n_s_objinfeasible __pyx_mstate_global->__pyx_n_s_objinfeasible +#define __pyx_n_s_objlimit __pyx_mstate_global->__pyx_n_s_objlimit +#define __pyx_n_s_objoffset __pyx_mstate_global->__pyx_n_s_objoffset +#define __pyx_n_s_objs __pyx_mstate_global->__pyx_n_s_objs +#define __pyx_n_s_objscale __pyx_mstate_global->__pyx_n_s_objscale +#define __pyx_n_s_objsense __pyx_mstate_global->__pyx_n_s_objsense +#define __pyx_n_s_objval __pyx_mstate_global->__pyx_n_s_objval +#define __pyx_n_s_offset __pyx_mstate_global->__pyx_n_s_offset +#define __pyx_n_s_onlychanged __pyx_mstate_global->__pyx_n_s_onlychanged +#define __pyx_n_s_onlyconvex __pyx_mstate_global->__pyx_n_s_onlyconvex +#define __pyx_n_s_onlydelayed __pyx_mstate_global->__pyx_n_s_onlydelayed +#define __pyx_n_s_onlyroot __pyx_mstate_global->__pyx_n_s_onlyroot +#define __pyx_n_s_op __pyx_mstate_global->__pyx_n_s_op +#define __pyx_n_s_op_2 __pyx_mstate_global->__pyx_n_s_op_2 +#define __pyx_n_s_open __pyx_mstate_global->__pyx_n_s_open +#define __pyx_n_s_opidx __pyx_mstate_global->__pyx_n_s_opidx +#define __pyx_n_s_optimal __pyx_mstate_global->__pyx_n_s_optimal +#define __pyx_n_u_optimal __pyx_mstate_global->__pyx_n_u_optimal +#define __pyx_n_s_optimize __pyx_mstate_global->__pyx_n_s_optimize +#define __pyx_n_s_origcopy __pyx_mstate_global->__pyx_n_s_origcopy +#define __pyx_n_s_original __pyx_mstate_global->__pyx_n_s_original +#define __pyx_kp_u_origprob_sol __pyx_mstate_global->__pyx_kp_u_origprob_sol +#define __pyx_kp_u_origprob_stats __pyx_mstate_global->__pyx_kp_u_origprob_stats +#define __pyx_n_s_orthofunc __pyx_mstate_global->__pyx_n_s_orthofunc +#define __pyx_n_s_os __pyx_mstate_global->__pyx_n_s_os +#define __pyx_n_s_os_path __pyx_mstate_global->__pyx_n_s_os_path +#define __pyx_n_s_other __pyx_mstate_global->__pyx_n_s_other +#define __pyx_n_s_paraemphasis __pyx_mstate_global->__pyx_n_s_paraemphasis +#define __pyx_n_s_param __pyx_mstate_global->__pyx_n_s_param +#define __pyx_kp_u_param_set __pyx_mstate_global->__pyx_kp_u_param_set +#define __pyx_n_s_params __pyx_mstate_global->__pyx_n_s_params +#define __pyx_n_s_paramtype __pyx_mstate_global->__pyx_n_s_paramtype +#define __pyx_n_s_partial __pyx_mstate_global->__pyx_n_s_partial +#define __pyx_n_s_partialsolution __pyx_mstate_global->__pyx_n_s_partialsolution +#define __pyx_n_s_path __pyx_mstate_global->__pyx_n_s_path +#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle +#define __pyx_n_s_plus __pyx_mstate_global->__pyx_n_s_plus +#define __pyx_n_s_pos __pyx_mstate_global->__pyx_n_s_pos +#define __pyx_n_s_power __pyx_mstate_global->__pyx_n_s_power +#define __pyx_n_s_prepare __pyx_mstate_global->__pyx_n_s_prepare +#define __pyx_n_s_presol __pyx_mstate_global->__pyx_n_s_presol +#define __pyx_n_s_presolexec __pyx_mstate_global->__pyx_n_s_presolexec +#define __pyx_n_s_presolexit __pyx_mstate_global->__pyx_n_s_presolexit +#define __pyx_n_s_presolexitpre __pyx_mstate_global->__pyx_n_s_presolexitpre +#define __pyx_n_s_presolfree __pyx_mstate_global->__pyx_n_s_presolfree +#define __pyx_n_s_presolinit __pyx_mstate_global->__pyx_n_s_presolinit +#define __pyx_n_s_presolinitpre __pyx_mstate_global->__pyx_n_s_presolinitpre +#define __pyx_n_s_presolmaxrounds __pyx_mstate_global->__pyx_n_s_presolmaxrounds +#define __pyx_n_s_presolpriority __pyx_mstate_global->__pyx_n_s_presolpriority +#define __pyx_n_s_presoltiming __pyx_mstate_global->__pyx_n_s_presoltiming +#define __pyx_n_s_presolve __pyx_mstate_global->__pyx_n_s_presolve +#define __pyx_n_s_pretendroot __pyx_mstate_global->__pyx_n_s_pretendroot +#define __pyx_n_s_pricedVar __pyx_mstate_global->__pyx_n_s_pricedVar +#define __pyx_n_s_pricedVarScore __pyx_mstate_global->__pyx_n_s_pricedVarScore +#define __pyx_n_s_pricer __pyx_mstate_global->__pyx_n_s_pricer +#define __pyx_n_s_pricerexit __pyx_mstate_global->__pyx_n_s_pricerexit +#define __pyx_n_s_pricerexitsol __pyx_mstate_global->__pyx_n_s_pricerexitsol +#define __pyx_n_s_pricerfarkas __pyx_mstate_global->__pyx_n_s_pricerfarkas +#define __pyx_kp_u_pricerfarkas_is_a_fundamental_ca __pyx_mstate_global->__pyx_kp_u_pricerfarkas_is_a_fundamental_ca +#define __pyx_n_s_pricerfree __pyx_mstate_global->__pyx_n_s_pricerfree +#define __pyx_n_s_pricerinit __pyx_mstate_global->__pyx_n_s_pricerinit +#define __pyx_n_s_pricerinitsol __pyx_mstate_global->__pyx_n_s_pricerinitsol +#define __pyx_n_s_pricerredcost __pyx_mstate_global->__pyx_n_s_pricerredcost +#define __pyx_kp_u_pricerredcost_is_a_fundamental_c __pyx_mstate_global->__pyx_kp_u_pricerredcost_is_a_fundamental_c +#define __pyx_n_u_primallimit __pyx_mstate_global->__pyx_n_u_primallimit +#define __pyx_n_s_primalsol __pyx_mstate_global->__pyx_n_s_primalsol +#define __pyx_n_s_print __pyx_mstate_global->__pyx_n_s_print +#define __pyx_n_s_printBestSol __pyx_mstate_global->__pyx_n_s_printBestSol +#define __pyx_n_s_printCons __pyx_mstate_global->__pyx_n_s_printCons +#define __pyx_n_s_printExternalCodeVersions __pyx_mstate_global->__pyx_n_s_printExternalCodeVersions +#define __pyx_n_s_printNlRow __pyx_mstate_global->__pyx_n_s_printNlRow +#define __pyx_n_s_printRow __pyx_mstate_global->__pyx_n_s_printRow +#define __pyx_n_s_printSol __pyx_mstate_global->__pyx_n_s_printSol +#define __pyx_n_s_printStatistics __pyx_mstate_global->__pyx_n_s_printStatistics +#define __pyx_n_s_printVersion __pyx_mstate_global->__pyx_n_s_printVersion +#define __pyx_n_s_print_memory_in_use __pyx_mstate_global->__pyx_n_s_print_memory_in_use +#define __pyx_n_s_printreason __pyx_mstate_global->__pyx_n_s_printreason +#define __pyx_n_s_priority __pyx_mstate_global->__pyx_n_s_priority +#define __pyx_n_s_probingdepth __pyx_mstate_global->__pyx_n_s_probingdepth +#define __pyx_n_s_problemName __pyx_mstate_global->__pyx_n_s_problemName +#define __pyx_n_s_probnumber __pyx_mstate_global->__pyx_n_s_probnumber +#define __pyx_n_s_prod __pyx_mstate_global->__pyx_n_s_prod +#define __pyx_n_u_prod __pyx_mstate_global->__pyx_n_u_prod +#define __pyx_n_s_prodexpr __pyx_mstate_global->__pyx_n_s_prodexpr +#define __pyx_n_s_prop __pyx_mstate_global->__pyx_n_s_prop +#define __pyx_n_s_propagate __pyx_mstate_global->__pyx_n_s_propagate +#define __pyx_n_u_propagate __pyx_mstate_global->__pyx_n_u_propagate +#define __pyx_n_s_propagateProbing __pyx_mstate_global->__pyx_n_s_propagateProbing +#define __pyx_kp_u_propagating_maxrounds __pyx_mstate_global->__pyx_kp_u_propagating_maxrounds +#define __pyx_kp_u_propagating_maxroundsroot __pyx_mstate_global->__pyx_kp_u_propagating_maxroundsroot +#define __pyx_n_s_propexec __pyx_mstate_global->__pyx_n_s_propexec +#define __pyx_n_s_propexit __pyx_mstate_global->__pyx_n_s_propexit +#define __pyx_n_s_propexitpre __pyx_mstate_global->__pyx_n_s_propexitpre +#define __pyx_n_s_propexitsol __pyx_mstate_global->__pyx_n_s_propexitsol +#define __pyx_n_s_propfree __pyx_mstate_global->__pyx_n_s_propfree +#define __pyx_n_s_propfreq __pyx_mstate_global->__pyx_n_s_propfreq +#define __pyx_n_s_propinit __pyx_mstate_global->__pyx_n_s_propinit +#define __pyx_n_s_propinitpre __pyx_mstate_global->__pyx_n_s_propinitpre +#define __pyx_n_s_propinitsol __pyx_mstate_global->__pyx_n_s_propinitsol +#define __pyx_n_s_proppresol __pyx_mstate_global->__pyx_n_s_proppresol +#define __pyx_n_s_propresprop __pyx_mstate_global->__pyx_n_s_propresprop +#define __pyx_n_s_proptiming __pyx_mstate_global->__pyx_n_s_proptiming +#define __pyx_n_s_proxy __pyx_mstate_global->__pyx_n_s_proxy +#define __pyx_n_s_pseudocands __pyx_mstate_global->__pyx_n_s_pseudocands +#define __pyx_n_s_ptr __pyx_mstate_global->__pyx_n_s_ptr +#define __pyx_n_s_ptrtuple __pyx_mstate_global->__pyx_n_s_ptrtuple +#define __pyx_n_u_ptrtuple __pyx_mstate_global->__pyx_n_u_ptrtuple +#define __pyx_n_s_pyCons __pyx_mstate_global->__pyx_n_s_pyCons +#define __pyx_n_s_pyVar __pyx_mstate_global->__pyx_n_s_pyVar +#define __pyx_n_s_py_boundtypes __pyx_mstate_global->__pyx_n_s_py_boundtypes +#define __pyx_n_s_py_branchbounds __pyx_mstate_global->__pyx_n_s_py_branchbounds +#define __pyx_n_s_py_variables __pyx_mstate_global->__pyx_n_s_py_variables +#define __pyx_n_s_pycons __pyx_mstate_global->__pyx_n_s_pycons +#define __pyx_n_s_pycons_initial __pyx_mstate_global->__pyx_n_s_pycons_initial +#define __pyx_n_s_pyscipopt_scip __pyx_mstate_global->__pyx_n_s_pyscipopt_scip +#define __pyx_kp_u_python_error_in_benderscreatesub __pyx_mstate_global->__pyx_kp_u_python_error_in_benderscreatesub +#define __pyx_kp_u_python_error_in_benderscutexec_t __pyx_mstate_global->__pyx_kp_u_python_error_in_benderscutexec_t +#define __pyx_kp_u_python_error_in_bendersgetvar_th __pyx_mstate_global->__pyx_kp_u_python_error_in_bendersgetvar_th +#define __pyx_kp_u_python_error_in_conscheck_this_m __pyx_mstate_global->__pyx_kp_u_python_error_in_conscheck_this_m +#define __pyx_kp_u_python_error_in_consenfolp_this __pyx_mstate_global->__pyx_kp_u_python_error_in_consenfolp_this +#define __pyx_kp_u_python_error_in_consenfops_this __pyx_mstate_global->__pyx_kp_u_python_error_in_consenfops_this +#define __pyx_kp_u_python_error_in_consenforelax_th __pyx_mstate_global->__pyx_kp_u_python_error_in_consenforelax_th +#define __pyx_kp_u_python_error_in_conslock_this_me __pyx_mstate_global->__pyx_kp_u_python_error_in_conslock_this_me +#define __pyx_kp_u_python_error_in_eventexec_this_m __pyx_mstate_global->__pyx_kp_u_python_error_in_eventexec_this_m +#define __pyx_kp_u_python_error_in_heurexec_this_me __pyx_mstate_global->__pyx_kp_u_python_error_in_heurexec_this_me +#define __pyx_kp_u_python_error_in_presolexec_this __pyx_mstate_global->__pyx_kp_u_python_error_in_presolexec_this +#define __pyx_kp_u_python_error_in_propexec_this_me __pyx_mstate_global->__pyx_kp_u_python_error_in_propexec_this_me +#define __pyx_kp_u_python_error_in_propresprop_this __pyx_mstate_global->__pyx_kp_u_python_error_in_propresprop_this +#define __pyx_kp_u_python_error_in_relaxexec_this_m __pyx_mstate_global->__pyx_kp_u_python_error_in_relaxexec_this_m +#define __pyx_n_s_pyvar __pyx_mstate_global->__pyx_n_s_pyvar +#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError +#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum +#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type +#define __pyx_n_s_pyx_unpickle_Benderscut __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Benderscut +#define __pyx_n_s_pyx_unpickle_Branchrule __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Branchrule +#define __pyx_n_s_pyx_unpickle_Conshdlr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Conshdlr +#define __pyx_n_s_pyx_unpickle_Constant __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Constant +#define __pyx_n_s_pyx_unpickle_Cutsel __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Cutsel +#define __pyx_n_s_pyx_unpickle_Eventhdlr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Eventhdlr +#define __pyx_n_s_pyx_unpickle_Expr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Expr +#define __pyx_n_s_pyx_unpickle_ExprCons __pyx_mstate_global->__pyx_n_s_pyx_unpickle_ExprCons +#define __pyx_n_s_pyx_unpickle_GenExpr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_GenExpr +#define __pyx_n_s_pyx_unpickle_Heur __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Heur +#define __pyx_n_s_pyx_unpickle_Nodesel __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Nodesel +#define __pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN +#define __pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR +#define __pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE +#define __pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN +#define __pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT +#define __pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE +#define __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH +#define __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT +#define __pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM +#define __pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN +#define __pyx_n_s_pyx_unpickle_PY_SCIP_RESULT __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_RESULT +#define __pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN +#define __pyx_n_s_pyx_unpickle_PY_SCIP_STAGE __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_STAGE +#define __pyx_n_s_pyx_unpickle_PY_SCIP_STATUS __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PY_SCIP_STATUS +#define __pyx_n_s_pyx_unpickle_PowExpr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_PowExpr +#define __pyx_n_s_pyx_unpickle_Presol __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Presol +#define __pyx_n_s_pyx_unpickle_Pricer __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Pricer +#define __pyx_n_s_pyx_unpickle_ProdExpr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_ProdExpr +#define __pyx_n_s_pyx_unpickle_Prop __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Prop +#define __pyx_n_s_pyx_unpickle_Reader __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Reader +#define __pyx_n_s_pyx_unpickle_Relax __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Relax +#define __pyx_n_s_pyx_unpickle_Sepa __pyx_mstate_global->__pyx_n_s_pyx_unpickle_Sepa +#define __pyx_n_s_pyx_unpickle_SumExpr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_SumExpr +#define __pyx_n_s_pyx_unpickle_UnaryExpr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_UnaryExpr +#define __pyx_n_s_pyx_unpickle_VarExpr __pyx_mstate_global->__pyx_n_s_pyx_unpickle_VarExpr +#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable +#define __pyx_n_s_quadcons __pyx_mstate_global->__pyx_n_s_quadcons +#define __pyx_n_u_quadratic __pyx_mstate_global->__pyx_n_u_quadratic +#define __pyx_n_s_quadterms __pyx_mstate_global->__pyx_n_s_quadterms +#define __pyx_n_s_quality __pyx_mstate_global->__pyx_n_s_quality +#define __pyx_n_s_qualname __pyx_mstate_global->__pyx_n_s_qualname +#define __pyx_n_s_quickprod __pyx_mstate_global->__pyx_n_s_quickprod +#define __pyx_n_s_quicksum __pyx_mstate_global->__pyx_n_s_quicksum +#define __pyx_n_s_quiet __pyx_mstate_global->__pyx_n_s_quiet +#define __pyx_n_s_raise_error __pyx_mstate_global->__pyx_n_s_raise_error +#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range +#define __pyx_n_s_ray __pyx_mstate_global->__pyx_n_s_ray +#define __pyx_n_s_rc __pyx_mstate_global->__pyx_n_s_rc +#define __pyx_n_s_readLP __pyx_mstate_global->__pyx_n_s_readLP +#define __pyx_n_s_readParams __pyx_mstate_global->__pyx_n_s_readParams +#define __pyx_n_s_readProblem __pyx_mstate_global->__pyx_n_s_readProblem +#define __pyx_n_s_readSol __pyx_mstate_global->__pyx_n_s_readSol +#define __pyx_n_s_readSolFile __pyx_mstate_global->__pyx_n_s_readSolFile +#define __pyx_n_s_reader __pyx_mstate_global->__pyx_n_s_reader +#define __pyx_n_s_readerfree __pyx_mstate_global->__pyx_n_s_readerfree +#define __pyx_n_s_readerread __pyx_mstate_global->__pyx_n_s_readerread +#define __pyx_n_s_readerwrite __pyx_mstate_global->__pyx_n_s_readerwrite +#define __pyx_n_s_redcost __pyx_mstate_global->__pyx_n_s_redcost +#define __pyx_n_s_redirectOutput __pyx_mstate_global->__pyx_n_s_redirectOutput +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_relax __pyx_mstate_global->__pyx_n_s_relax +#define __pyx_n_s_relaxcons __pyx_mstate_global->__pyx_n_s_relaxcons +#define __pyx_n_s_relaxedbd __pyx_mstate_global->__pyx_n_s_relaxedbd +#define __pyx_n_s_relaxexec __pyx_mstate_global->__pyx_n_s_relaxexec +#define __pyx_kp_u_relaxexec_must_return_a_dictiona __pyx_mstate_global->__pyx_kp_u_relaxexec_must_return_a_dictiona +#define __pyx_n_s_relaxexit __pyx_mstate_global->__pyx_n_s_relaxexit +#define __pyx_n_s_relaxexitsol __pyx_mstate_global->__pyx_n_s_relaxexitsol +#define __pyx_n_s_relaxfree __pyx_mstate_global->__pyx_n_s_relaxfree +#define __pyx_n_s_relaxinit __pyx_mstate_global->__pyx_n_s_relaxinit +#define __pyx_n_s_relaxinitsol __pyx_mstate_global->__pyx_n_s_relaxinitsol +#define __pyx_n_s_releaseRow __pyx_mstate_global->__pyx_n_s_releaseRow +#define __pyx_n_s_removable __pyx_mstate_global->__pyx_n_s_removable +#define __pyx_n_u_removable __pyx_mstate_global->__pyx_n_u_removable +#define __pyx_n_s_repeat __pyx_mstate_global->__pyx_n_s_repeat +#define __pyx_n_s_repr __pyx_mstate_global->__pyx_n_s_repr +#define __pyx_n_s_repr___locals_lambda __pyx_mstate_global->__pyx_n_s_repr___locals_lambda +#define __pyx_n_s_repropagateNode __pyx_mstate_global->__pyx_n_s_repropagateNode +#define __pyx_n_s_resVar __pyx_mstate_global->__pyx_n_s_resVar +#define __pyx_n_s_resetParam __pyx_mstate_global->__pyx_n_s_resetParam +#define __pyx_n_s_resetParams __pyx_mstate_global->__pyx_n_s_resetParams +#define __pyx_n_s_restart __pyx_mstate_global->__pyx_n_s_restart +#define __pyx_n_s_restartSolve __pyx_mstate_global->__pyx_n_s_restartSolve +#define __pyx_n_u_restartlimit __pyx_mstate_global->__pyx_n_u_restartlimit +#define __pyx_n_s_result __pyx_mstate_global->__pyx_n_s_result +#define __pyx_n_u_result __pyx_mstate_global->__pyx_n_u_result +#define __pyx_n_s_result_dict __pyx_mstate_global->__pyx_n_s_result_dict +#define __pyx_n_s_resvar __pyx_mstate_global->__pyx_n_s_resvar +#define __pyx_n_s_retcode __pyx_mstate_global->__pyx_n_s_retcode +#define __pyx_n_s_rhs __pyx_mstate_global->__pyx_n_s_rhs +#define __pyx_n_u_rhs __pyx_mstate_global->__pyx_n_u_rhs +#define __pyx_n_s_rhs_2 __pyx_mstate_global->__pyx_n_s_rhs_2 +#define __pyx_n_s_rhss __pyx_mstate_global->__pyx_n_s_rhss +#define __pyx_n_s_rhsslack __pyx_mstate_global->__pyx_n_s_rhsslack +#define __pyx_n_s_rhsvar __pyx_mstate_global->__pyx_n_s_rhsvar +#define __pyx_n_s_root __pyx_mstate_global->__pyx_n_s_root +#define __pyx_n_s_row __pyx_mstate_global->__pyx_n_s_row +#define __pyx_n_u_row __pyx_mstate_global->__pyx_n_u_row +#define __pyx_n_s_row1 __pyx_mstate_global->__pyx_n_s_row1 +#define __pyx_n_s_row2 __pyx_mstate_global->__pyx_n_s_row2 +#define __pyx_n_s_rows __pyx_mstate_global->__pyx_n_s_rows +#define __pyx_n_s_scip_benders __pyx_mstate_global->__pyx_n_s_scip_benders +#define __pyx_n_s_scip_benderscut __pyx_mstate_global->__pyx_n_s_scip_benderscut +#define __pyx_n_s_scip_col __pyx_mstate_global->__pyx_n_s_scip_col +#define __pyx_n_s_scip_con __pyx_mstate_global->__pyx_n_s_scip_con +#define __pyx_n_s_scip_cons __pyx_mstate_global->__pyx_n_s_scip_cons +#define __pyx_n_s_scip_conshdlr __pyx_mstate_global->__pyx_n_s_scip_conshdlr +#define __pyx_n_s_scip_expr __pyx_mstate_global->__pyx_n_s_scip_expr +#define __pyx_n_s_scip_pricer __pyx_mstate_global->__pyx_n_s_scip_pricer +#define __pyx_n_s_scip_sepa __pyx_mstate_global->__pyx_n_s_scip_sepa +#define __pyx_n_s_scip_sol __pyx_mstate_global->__pyx_n_s_scip_sol +#define __pyx_n_s_scip_subprob __pyx_mstate_global->__pyx_n_s_scip_subprob +#define __pyx_n_s_scip_var __pyx_mstate_global->__pyx_n_s_scip_var +#define __pyx_n_s_scipexprs __pyx_mstate_global->__pyx_n_s_scipexprs +#define __pyx_n_s_scipvar1 __pyx_mstate_global->__pyx_n_s_scipvar1 +#define __pyx_n_s_scipvar2 __pyx_mstate_global->__pyx_n_s_scipvar2 +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_kp_s_self__benders_cannot_be_converte __pyx_mstate_global->__pyx_kp_s_self__benders_cannot_be_converte +#define __pyx_kp_s_self__scip_self__valid_cannot_be __pyx_mstate_global->__pyx_kp_s_self__scip_self__valid_cannot_be +#define __pyx_kp_s_self_event_cannot_be_converted_t __pyx_mstate_global->__pyx_kp_s_self_event_cannot_be_converted_t +#define __pyx_kp_s_self_lpi_cannot_be_converted_to __pyx_mstate_global->__pyx_kp_s_self_lpi_cannot_be_converted_to +#define __pyx_kp_s_self_scip_boundchg_cannot_be_con __pyx_mstate_global->__pyx_kp_s_self_scip_boundchg_cannot_be_con +#define __pyx_kp_s_self_scip_col_cannot_be_converte __pyx_mstate_global->__pyx_kp_s_self_scip_col_cannot_be_converte +#define __pyx_kp_s_self_scip_cons_cannot_be_convert __pyx_mstate_global->__pyx_kp_s_self_scip_cons_cannot_be_convert +#define __pyx_kp_s_self_scip_domchg_cannot_be_conve __pyx_mstate_global->__pyx_kp_s_self_scip_domchg_cannot_be_conve +#define __pyx_kp_s_self_scip_nlrow_cannot_be_conver __pyx_mstate_global->__pyx_kp_s_self_scip_nlrow_cannot_be_conver +#define __pyx_kp_s_self_scip_node_cannot_be_convert __pyx_mstate_global->__pyx_kp_s_self_scip_node_cannot_be_convert +#define __pyx_kp_s_self_scip_row_cannot_be_converte __pyx_mstate_global->__pyx_kp_s_self_scip_row_cannot_be_converte +#define __pyx_kp_s_self_scip_self_sol_cannot_be_con __pyx_mstate_global->__pyx_kp_s_self_scip_self_sol_cannot_be_con +#define __pyx_kp_s_self_scip_var_cannot_be_converte __pyx_mstate_global->__pyx_kp_s_self_scip_var_cannot_be_converte +#define __pyx_n_u_selnode __pyx_mstate_global->__pyx_n_u_selnode +#define __pyx_n_s_send __pyx_mstate_global->__pyx_n_s_send +#define __pyx_n_s_sense __pyx_mstate_global->__pyx_n_s_sense +#define __pyx_n_s_sepa __pyx_mstate_global->__pyx_n_s_sepa +#define __pyx_n_s_sepaexeclp __pyx_mstate_global->__pyx_n_s_sepaexeclp +#define __pyx_n_s_sepaexecsol __pyx_mstate_global->__pyx_n_s_sepaexecsol +#define __pyx_n_s_sepaexit __pyx_mstate_global->__pyx_n_s_sepaexit +#define __pyx_n_s_sepaexitsol __pyx_mstate_global->__pyx_n_s_sepaexitsol +#define __pyx_n_s_sepafree __pyx_mstate_global->__pyx_n_s_sepafree +#define __pyx_n_s_sepafreq __pyx_mstate_global->__pyx_n_s_sepafreq +#define __pyx_n_s_sepainit __pyx_mstate_global->__pyx_n_s_sepainit +#define __pyx_n_s_sepainitsol __pyx_mstate_global->__pyx_n_s_sepainitsol +#define __pyx_n_s_sepapriority __pyx_mstate_global->__pyx_n_s_sepapriority +#define __pyx_n_s_separate __pyx_mstate_global->__pyx_n_s_separate +#define __pyx_n_u_separate __pyx_mstate_global->__pyx_n_u_separate +#define __pyx_n_s_separateSol __pyx_mstate_global->__pyx_n_s_separateSol +#define __pyx_n_s_setBendersSubproblemIsConvex __pyx_mstate_global->__pyx_n_s_setBendersSubproblemIsConvex +#define __pyx_n_s_setBoolParam __pyx_mstate_global->__pyx_n_s_setBoolParam +#define __pyx_n_s_setCharParam __pyx_mstate_global->__pyx_n_s_setCharParam +#define __pyx_n_s_setCheck __pyx_mstate_global->__pyx_n_s_setCheck +#define __pyx_n_s_setEmphasis __pyx_mstate_global->__pyx_n_s_setEmphasis +#define __pyx_n_s_setEnforced __pyx_mstate_global->__pyx_n_s_setEnforced +#define __pyx_n_s_setHeuristics __pyx_mstate_global->__pyx_n_s_setHeuristics +#define __pyx_n_s_setInitial __pyx_mstate_global->__pyx_n_s_setInitial +#define __pyx_n_s_setIntParam __pyx_mstate_global->__pyx_n_s_setIntParam +#define __pyx_n_s_setLogfile __pyx_mstate_global->__pyx_n_s_setLogfile +#define __pyx_n_s_setLongintParam __pyx_mstate_global->__pyx_n_s_setLongintParam +#define __pyx_n_s_setMaximize __pyx_mstate_global->__pyx_n_s_setMaximize +#define __pyx_n_s_setMinimize __pyx_mstate_global->__pyx_n_s_setMinimize +#define __pyx_n_s_setObjIntegral __pyx_mstate_global->__pyx_n_s_setObjIntegral +#define __pyx_n_s_setObjective __pyx_mstate_global->__pyx_n_s_setObjective +#define __pyx_n_s_setObjlimit __pyx_mstate_global->__pyx_n_s_setObjlimit +#define __pyx_n_s_setParam __pyx_mstate_global->__pyx_n_s_setParam +#define __pyx_n_s_setParams __pyx_mstate_global->__pyx_n_s_setParams +#define __pyx_n_s_setParamsCountsols __pyx_mstate_global->__pyx_n_s_setParamsCountsols +#define __pyx_n_s_setPresolve __pyx_mstate_global->__pyx_n_s_setPresolve +#define __pyx_n_s_setProbName __pyx_mstate_global->__pyx_n_s_setProbName +#define __pyx_n_s_setRealParam __pyx_mstate_global->__pyx_n_s_setRealParam +#define __pyx_n_s_setRelaxSolVal __pyx_mstate_global->__pyx_n_s_setRelaxSolVal +#define __pyx_n_s_setRemovable __pyx_mstate_global->__pyx_n_s_setRemovable +#define __pyx_n_s_setSeparating __pyx_mstate_global->__pyx_n_s_setSeparating +#define __pyx_n_s_setSolVal __pyx_mstate_global->__pyx_n_s_setSolVal +#define __pyx_n_s_setStringParam __pyx_mstate_global->__pyx_n_s_setStringParam +#define __pyx_n_s_set_name __pyx_mstate_global->__pyx_n_s_set_name +#define __pyx_n_s_setlocale __pyx_mstate_global->__pyx_n_s_setlocale +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_setting __pyx_mstate_global->__pyx_n_s_setting +#define __pyx_n_s_setupBendersSubproblem __pyx_mstate_global->__pyx_n_s_setupBendersSubproblem +#define __pyx_n_s_shareaux __pyx_mstate_global->__pyx_n_s_shareaux +#define __pyx_n_s_siblings __pyx_mstate_global->__pyx_n_s_siblings +#define __pyx_n_s_siblings_2 __pyx_mstate_global->__pyx_n_s_siblings_2 +#define __pyx_n_s_side __pyx_mstate_global->__pyx_n_s_side +#define __pyx_n_s_sin __pyx_mstate_global->__pyx_n_s_sin +#define __pyx_n_u_sin __pyx_mstate_global->__pyx_n_u_sin +#define __pyx_n_u_skipsolve __pyx_mstate_global->__pyx_n_u_skipsolve +#define __pyx_n_s_slots __pyx_mstate_global->__pyx_n_s_slots +#define __pyx_n_s_sol __pyx_mstate_global->__pyx_n_s_sol +#define __pyx_n_s_sol_2 __pyx_mstate_global->__pyx_n_s_sol_2 +#define __pyx_n_s_solinfeasible __pyx_mstate_global->__pyx_n_s_solinfeasible +#define __pyx_n_u_sollimit __pyx_mstate_global->__pyx_n_u_sollimit +#define __pyx_n_s_solptr __pyx_mstate_global->__pyx_n_s_solptr +#define __pyx_n_s_sols __pyx_mstate_global->__pyx_n_s_sols +#define __pyx_n_s_sols_2 __pyx_mstate_global->__pyx_n_s_sols_2 +#define __pyx_n_s_solution __pyx_mstate_global->__pyx_n_s_solution +#define __pyx_n_s_solutions __pyx_mstate_global->__pyx_n_s_solutions +#define __pyx_n_s_solve __pyx_mstate_global->__pyx_n_s_solve +#define __pyx_n_s_solveBendersSubproblem __pyx_mstate_global->__pyx_n_s_solveBendersSubproblem +#define __pyx_n_s_solveConcurrent __pyx_mstate_global->__pyx_n_s_solveConcurrent +#define __pyx_n_s_solveDiveLP __pyx_mstate_global->__pyx_n_s_solveDiveLP +#define __pyx_n_s_solveProbingLP __pyx_mstate_global->__pyx_n_s_solveProbingLP +#define __pyx_n_s_solvecip __pyx_mstate_global->__pyx_n_s_solvecip +#define __pyx_n_s_sorted __pyx_mstate_global->__pyx_n_s_sorted +#define __pyx_n_s_sourceModel __pyx_mstate_global->__pyx_n_s_sourceModel +#define __pyx_n_s_sourceconstraint __pyx_mstate_global->__pyx_n_s_sourceconstraint +#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec +#define __pyx_n_s_splitext __pyx_mstate_global->__pyx_n_s_splitext +#define __pyx_n_s_sqrcoef __pyx_mstate_global->__pyx_n_s_sqrcoef +#define __pyx_n_s_sqrexpr __pyx_mstate_global->__pyx_n_s_sqrexpr +#define __pyx_n_s_sqrt __pyx_mstate_global->__pyx_n_s_sqrt +#define __pyx_n_u_sqrt __pyx_mstate_global->__pyx_n_u_sqrt +#define __pyx_kp_s_src_pyscipopt_benders_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_benders_pxi +#define __pyx_kp_s_src_pyscipopt_benderscut_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_benderscut_pxi +#define __pyx_kp_s_src_pyscipopt_branchrule_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_branchrule_pxi +#define __pyx_kp_s_src_pyscipopt_conshdlr_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_conshdlr_pxi +#define __pyx_kp_s_src_pyscipopt_cutsel_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_cutsel_pxi +#define __pyx_kp_s_src_pyscipopt_event_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_event_pxi +#define __pyx_kp_s_src_pyscipopt_expr_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_expr_pxi +#define __pyx_kp_s_src_pyscipopt_heuristic_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_heuristic_pxi +#define __pyx_kp_s_src_pyscipopt_lp_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_lp_pxi +#define __pyx_kp_s_src_pyscipopt_nodesel_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_nodesel_pxi +#define __pyx_kp_s_src_pyscipopt_presol_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_presol_pxi +#define __pyx_kp_s_src_pyscipopt_pricer_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_pricer_pxi +#define __pyx_kp_s_src_pyscipopt_propagator_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_propagator_pxi +#define __pyx_kp_s_src_pyscipopt_reader_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_reader_pxi +#define __pyx_kp_s_src_pyscipopt_relax_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_relax_pxi +#define __pyx_kp_s_src_pyscipopt_scip_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_scip_pxi +#define __pyx_kp_s_src_pyscipopt_sepa_pxi __pyx_mstate_global->__pyx_kp_s_src_pyscipopt_sepa_pxi +#define __pyx_n_u_stallnodelimit __pyx_mstate_global->__pyx_n_u_stallnodelimit +#define __pyx_n_s_startDive __pyx_mstate_global->__pyx_n_s_startDive +#define __pyx_n_s_startProbing __pyx_mstate_global->__pyx_n_s_startProbing +#define __pyx_n_s_startnconss __pyx_mstate_global->__pyx_n_s_startnconss +#define __pyx_n_s_startnvars __pyx_mstate_global->__pyx_n_s_startnvars +#define __pyx_n_s_stat __pyx_mstate_global->__pyx_n_s_stat +#define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state +#define __pyx_n_s_staticmethod __pyx_mstate_global->__pyx_n_s_staticmethod +#define __pyx_n_s_stderr __pyx_mstate_global->__pyx_n_s_stderr +#define __pyx_n_s_stdout __pyx_mstate_global->__pyx_n_s_stdout +#define __pyx_n_s_stdpriority __pyx_mstate_global->__pyx_n_s_stdpriority +#define __pyx_n_s_stickingatnode __pyx_mstate_global->__pyx_n_s_stickingatnode +#define __pyx_n_u_stickingatnode __pyx_mstate_global->__pyx_n_u_stickingatnode +#define __pyx_n_u_stopearly __pyx_mstate_global->__pyx_n_u_stopearly +#define __pyx_n_s_stored __pyx_mstate_global->__pyx_n_s_stored +#define __pyx_n_s_str_absfile __pyx_mstate_global->__pyx_n_s_str_absfile +#define __pyx_n_s_str_conversion __pyx_mstate_global->__pyx_n_s_str_conversion +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_subprob __pyx_mstate_global->__pyx_n_s_subprob +#define __pyx_n_s_subproblem __pyx_mstate_global->__pyx_n_s_subproblem +#define __pyx_n_s_subproblems __pyx_mstate_global->__pyx_n_s_subproblems +#define __pyx_n_s_subprobs __pyx_mstate_global->__pyx_n_s_subprobs +#define __pyx_n_s_success __pyx_mstate_global->__pyx_n_s_success +#define __pyx_n_u_success __pyx_mstate_global->__pyx_n_u_success +#define __pyx_n_s_sum __pyx_mstate_global->__pyx_n_s_sum +#define __pyx_n_u_sum __pyx_mstate_global->__pyx_n_u_sum +#define __pyx_n_s_sumexpr __pyx_mstate_global->__pyx_n_s_sumexpr +#define __pyx_n_s_super __pyx_mstate_global->__pyx_n_s_super +#define __pyx_n_s_sys __pyx_mstate_global->__pyx_n_s_sys +#define __pyx_n_s_t __pyx_mstate_global->__pyx_n_s_t +#define __pyx_n_s_take_ownership __pyx_mstate_global->__pyx_n_s_take_ownership +#define __pyx_n_u_targetcons __pyx_mstate_global->__pyx_n_u_targetcons +#define __pyx_n_s_targetvalue __pyx_mstate_global->__pyx_n_s_targetvalue +#define __pyx_n_s_temp_cons __pyx_mstate_global->__pyx_n_s_temp_cons +#define __pyx_n_s_term __pyx_mstate_global->__pyx_n_s_term +#define __pyx_kp_u_term_length_must_be_1_or_2_but_i __pyx_mstate_global->__pyx_kp_u_term_length_must_be_1_or_2_but_i +#define __pyx_n_s_termcoefs __pyx_mstate_global->__pyx_n_s_termcoefs +#define __pyx_n_s_termidx __pyx_mstate_global->__pyx_n_s_termidx +#define __pyx_n_s_termlist __pyx_mstate_global->__pyx_n_s_termlist +#define __pyx_n_s_terms __pyx_mstate_global->__pyx_n_s_terms +#define __pyx_n_s_termvars __pyx_mstate_global->__pyx_n_s_termvars +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_threadsafe __pyx_mstate_global->__pyx_n_s_threadsafe +#define __pyx_n_s_throw __pyx_mstate_global->__pyx_n_s_throw +#define __pyx_n_s_tightenVarLb __pyx_mstate_global->__pyx_n_s_tightenVarLb +#define __pyx_n_s_tightenVarLbGlobal __pyx_mstate_global->__pyx_n_s_tightenVarLbGlobal +#define __pyx_n_s_tightenVarUb __pyx_mstate_global->__pyx_n_s_tightenVarUb +#define __pyx_n_s_tightenVarUbGlobal __pyx_mstate_global->__pyx_n_s_tightenVarUbGlobal +#define __pyx_n_s_tightened __pyx_mstate_global->__pyx_n_s_tightened +#define __pyx_n_u_timelimit __pyx_mstate_global->__pyx_n_u_timelimit +#define __pyx_n_s_timing __pyx_mstate_global->__pyx_n_s_timing +#define __pyx_n_s_timingmask __pyx_mstate_global->__pyx_n_s_timingmask +#define __pyx_n_s_tmp __pyx_mstate_global->__pyx_n_s_tmp +#define __pyx_n_s_to_ptr __pyx_mstate_global->__pyx_n_s_to_ptr +#define __pyx_kp_u_total_number_of_solutions_found __pyx_mstate_global->__pyx_kp_u_total_number_of_solutions_found +#define __pyx_n_u_totalnodelimit __pyx_mstate_global->__pyx_n_u_totalnodelimit +#define __pyx_n_s_trans __pyx_mstate_global->__pyx_n_s_trans +#define __pyx_n_s_transcons __pyx_mstate_global->__pyx_n_s_transcons +#define __pyx_n_s_transformed __pyx_mstate_global->__pyx_n_s_transformed +#define __pyx_kp_u_transprob_sol __pyx_mstate_global->__pyx_kp_u_transprob_sol +#define __pyx_n_u_true __pyx_mstate_global->__pyx_n_u_true +#define __pyx_n_s_truediv __pyx_mstate_global->__pyx_n_s_truediv +#define __pyx_n_s_trySol __pyx_mstate_global->__pyx_n_s_trySol +#define __pyx_n_s_tvar __pyx_mstate_global->__pyx_n_s_tvar +#define __pyx_n_s_typing __pyx_mstate_global->__pyx_n_s_typing +#define __pyx_n_s_ub __pyx_mstate_global->__pyx_n_s_ub +#define __pyx_n_s_ubs __pyx_mstate_global->__pyx_n_s_ubs +#define __pyx_n_u_unbounded __pyx_mstate_global->__pyx_n_u_unbounded +#define __pyx_n_u_unknown __pyx_mstate_global->__pyx_n_u_unknown +#define __pyx_kp_u_unrecognized_objective_sense __pyx_mstate_global->__pyx_kp_u_unrecognized_objective_sense +#define __pyx_kp_u_unrecognized_optimization_sense __pyx_mstate_global->__pyx_kp_u_unrecognized_optimization_sense +#define __pyx_kp_u_unrecognized_variable_type __pyx_mstate_global->__pyx_kp_u_unrecognized_variable_type +#define __pyx_n_s_upchild __pyx_mstate_global->__pyx_n_s_upchild +#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update +#define __pyx_n_s_updateBendersLowerbounds __pyx_mstate_global->__pyx_n_s_updateBendersLowerbounds +#define __pyx_n_s_updateNodeLowerbound __pyx_mstate_global->__pyx_n_s_updateNodeLowerbound +#define __pyx_n_s_upper __pyx_mstate_global->__pyx_n_s_upper +#define __pyx_n_u_upper __pyx_mstate_global->__pyx_n_u_upper +#define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate +#define __pyx_n_s_user_locale __pyx_mstate_global->__pyx_n_s_user_locale +#define __pyx_n_u_userinterrupt __pyx_mstate_global->__pyx_n_u_userinterrupt +#define __pyx_n_s_usessubscip __pyx_mstate_global->__pyx_n_s_usessubscip +#define __pyx_kp_u_utf_8 __pyx_mstate_global->__pyx_kp_u_utf_8 +#define __pyx_n_s_v __pyx_mstate_global->__pyx_n_s_v +#define __pyx_n_s_val __pyx_mstate_global->__pyx_n_s_val +#define __pyx_n_s_val1 __pyx_mstate_global->__pyx_n_s_val1 +#define __pyx_n_s_val2 __pyx_mstate_global->__pyx_n_s_val2 +#define __pyx_n_s_valid __pyx_mstate_global->__pyx_n_s_valid +#define __pyx_n_s_validnode __pyx_mstate_global->__pyx_n_s_validnode +#define __pyx_n_s_vals __pyx_mstate_global->__pyx_n_s_vals +#define __pyx_n_s_vals_2 __pyx_mstate_global->__pyx_n_s_vals_2 +#define __pyx_n_s_valsdict __pyx_mstate_global->__pyx_n_s_valsdict +#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value +#define __pyx_n_s_value_to_array __pyx_mstate_global->__pyx_n_s_value_to_array +#define __pyx_n_s_valuenode __pyx_mstate_global->__pyx_n_s_valuenode +#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values +#define __pyx_n_s_var __pyx_mstate_global->__pyx_n_s_var +#define __pyx_n_u_var __pyx_mstate_global->__pyx_n_u_var +#define __pyx_n_s_var1 __pyx_mstate_global->__pyx_n_s_var1 +#define __pyx_n_s_var2 __pyx_mstate_global->__pyx_n_s_var2 +#define __pyx_n_s_var_2 __pyx_mstate_global->__pyx_n_s_var_2 +#define __pyx_n_s_var_dict __pyx_mstate_global->__pyx_n_s_var_dict +#define __pyx_n_s_varexpr __pyx_mstate_global->__pyx_n_s_varexpr +#define __pyx_n_s_varexprs __pyx_mstate_global->__pyx_n_s_varexprs +#define __pyx_n_s_variable __pyx_mstate_global->__pyx_n_s_variable +#define __pyx_n_s_variables __pyx_mstate_global->__pyx_n_s_variables +#define __pyx_n_s_varidx __pyx_mstate_global->__pyx_n_s_varidx +#define __pyx_n_s_varindex __pyx_mstate_global->__pyx_n_s_varindex +#define __pyx_n_s_varpos __pyx_mstate_global->__pyx_n_s_varpos +#define __pyx_n_s_vars __pyx_mstate_global->__pyx_n_s_vars +#define __pyx_n_s_vars_2 __pyx_mstate_global->__pyx_n_s_vars_2 +#define __pyx_n_s_vars_array __pyx_mstate_global->__pyx_n_s_vars_array +#define __pyx_n_s_vartuple __pyx_mstate_global->__pyx_n_s_vartuple +#define __pyx_n_u_vartuple __pyx_mstate_global->__pyx_n_u_vartuple +#define __pyx_n_s_vartype __pyx_mstate_global->__pyx_n_s_vartype +#define __pyx_n_s_verbose __pyx_mstate_global->__pyx_n_s_verbose +#define __pyx_n_s_version __pyx_mstate_global->__pyx_n_s_version +#define __pyx_n_s_version_info __pyx_mstate_global->__pyx_n_s_version_info +#define __pyx_n_s_vtype __pyx_mstate_global->__pyx_n_s_vtype +#define __pyx_n_u_w __pyx_mstate_global->__pyx_n_u_w +#define __pyx_n_s_warn __pyx_mstate_global->__pyx_n_s_warn +#define __pyx_n_s_warnings __pyx_mstate_global->__pyx_n_s_warnings +#define __pyx_n_s_weakref __pyx_mstate_global->__pyx_n_s_weakref +#define __pyx_n_s_weight __pyx_mstate_global->__pyx_n_s_weight +#define __pyx_n_s_weights __pyx_mstate_global->__pyx_n_s_weights +#define __pyx_n_s_write __pyx_mstate_global->__pyx_n_s_write +#define __pyx_n_s_writeBestSol __pyx_mstate_global->__pyx_n_s_writeBestSol +#define __pyx_n_s_writeBestTransSol __pyx_mstate_global->__pyx_n_s_writeBestTransSol +#define __pyx_n_s_writeLP __pyx_mstate_global->__pyx_n_s_writeLP +#define __pyx_n_s_writeName __pyx_mstate_global->__pyx_n_s_writeName +#define __pyx_n_s_writeParams __pyx_mstate_global->__pyx_n_s_writeParams +#define __pyx_n_s_writeProblem __pyx_mstate_global->__pyx_n_s_writeProblem +#define __pyx_n_s_writeSol __pyx_mstate_global->__pyx_n_s_writeSol +#define __pyx_n_s_writeStatistics __pyx_mstate_global->__pyx_n_s_writeStatistics +#define __pyx_n_s_writeTransSol __pyx_mstate_global->__pyx_n_s_writeTransSol +#define __pyx_n_s_write_zeros __pyx_mstate_global->__pyx_n_s_write_zeros +#define __pyx_kp_u_wrote_parameter_settings_to_file __pyx_mstate_global->__pyx_kp_u_wrote_parameter_settings_to_file +#define __pyx_kp_u_wrote_problem_to_file __pyx_mstate_global->__pyx_kp_u_wrote_problem_to_file +#define __pyx_n_s_x __pyx_mstate_global->__pyx_n_s_x +#define __pyx_n_u_x __pyx_mstate_global->__pyx_n_u_x +#define __pyx_n_u_zero __pyx_mstate_global->__pyx_n_u_zero +#define __pyx_float_0_0 __pyx_mstate_global->__pyx_float_0_0 +#define __pyx_float_1_0 __pyx_mstate_global->__pyx_float_1_0 +#define __pyx_float_10_0 __pyx_mstate_global->__pyx_float_10_0 +#define __pyx_float_100_0 __pyx_mstate_global->__pyx_float_100_0 +#define __pyx_float_1e_20 __pyx_mstate_global->__pyx_float_1e_20 +#define __pyx_float_neg_1_0 __pyx_mstate_global->__pyx_float_neg_1_0 +#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 +#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 +#define __pyx_int_2 __pyx_mstate_global->__pyx_int_2 +#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 +#define __pyx_int_5 __pyx_mstate_global->__pyx_int_5 +#define __pyx_int_9 __pyx_mstate_global->__pyx_int_9 +#define __pyx_int_10 __pyx_mstate_global->__pyx_int_10 +#define __pyx_int_100 __pyx_mstate_global->__pyx_int_100 +#define __pyx_int_101 __pyx_mstate_global->__pyx_int_101 +#define __pyx_int_10000 __pyx_mstate_global->__pyx_int_10000 +#define __pyx_int_13758880 __pyx_mstate_global->__pyx_int_13758880 +#define __pyx_int_25280761 __pyx_mstate_global->__pyx_int_25280761 +#define __pyx_int_30435853 __pyx_mstate_global->__pyx_int_30435853 +#define __pyx_int_34551270 __pyx_mstate_global->__pyx_int_34551270 +#define __pyx_int_37557029 __pyx_mstate_global->__pyx_int_37557029 +#define __pyx_int_63254455 __pyx_mstate_global->__pyx_int_63254455 +#define __pyx_int_76513566 __pyx_mstate_global->__pyx_int_76513566 +#define __pyx_int_76998962 __pyx_mstate_global->__pyx_int_76998962 +#define __pyx_int_80720285 __pyx_mstate_global->__pyx_int_80720285 +#define __pyx_int_85795681 __pyx_mstate_global->__pyx_int_85795681 +#define __pyx_int_95355963 __pyx_mstate_global->__pyx_int_95355963 +#define __pyx_int_114651189 __pyx_mstate_global->__pyx_int_114651189 +#define __pyx_int_116691903 __pyx_mstate_global->__pyx_int_116691903 +#define __pyx_int_132603380 __pyx_mstate_global->__pyx_int_132603380 +#define __pyx_int_135158539 __pyx_mstate_global->__pyx_int_135158539 +#define __pyx_int_143015212 __pyx_mstate_global->__pyx_int_143015212 +#define __pyx_int_147635180 __pyx_mstate_global->__pyx_int_147635180 +#define __pyx_int_150239579 __pyx_mstate_global->__pyx_int_150239579 +#define __pyx_int_152146234 __pyx_mstate_global->__pyx_int_152146234 +#define __pyx_int_154610759 __pyx_mstate_global->__pyx_int_154610759 +#define __pyx_int_169888372 __pyx_mstate_global->__pyx_int_169888372 +#define __pyx_int_173957064 __pyx_mstate_global->__pyx_int_173957064 +#define __pyx_int_176834982 __pyx_mstate_global->__pyx_int_176834982 +#define __pyx_int_201230365 __pyx_mstate_global->__pyx_int_201230365 +#define __pyx_int_204489503 __pyx_mstate_global->__pyx_int_204489503 +#define __pyx_int_208012509 __pyx_mstate_global->__pyx_int_208012509 +#define __pyx_int_208195651 __pyx_mstate_global->__pyx_int_208195651 +#define __pyx_int_214626690 __pyx_mstate_global->__pyx_int_214626690 +#define __pyx_int_216408278 __pyx_mstate_global->__pyx_int_216408278 +#define __pyx_int_222419149 __pyx_mstate_global->__pyx_int_222419149 +#define __pyx_int_228825662 __pyx_mstate_global->__pyx_int_228825662 +#define __pyx_int_238750788 __pyx_mstate_global->__pyx_int_238750788 +#define __pyx_int_240430858 __pyx_mstate_global->__pyx_int_240430858 +#define __pyx_int_248330301 __pyx_mstate_global->__pyx_int_248330301 +#define __pyx_int_253686829 __pyx_mstate_global->__pyx_int_253686829 +#define __pyx_int_267356384 __pyx_mstate_global->__pyx_int_267356384 +#define __pyx_int_neg_1 __pyx_mstate_global->__pyx_int_neg_1 +#define __pyx_k__101 __pyx_mstate_global->__pyx_k__101 +#define __pyx_k__102 __pyx_mstate_global->__pyx_k__102 +#define __pyx_k__103 __pyx_mstate_global->__pyx_k__103 +#define __pyx_k__104 __pyx_mstate_global->__pyx_k__104 +#define __pyx_k__105 __pyx_mstate_global->__pyx_k__105 +#define __pyx_k__106 __pyx_mstate_global->__pyx_k__106 +#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ +#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 +#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 +#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 +#define __pyx_tuple__7 __pyx_mstate_global->__pyx_tuple__7 +#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 +#define __pyx_slice__88 __pyx_mstate_global->__pyx_slice__88 +#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 +#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 +#define __pyx_tuple__13 __pyx_mstate_global->__pyx_tuple__13 +#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 +#define __pyx_tuple__15 __pyx_mstate_global->__pyx_tuple__15 +#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 +#define __pyx_tuple__17 __pyx_mstate_global->__pyx_tuple__17 +#define __pyx_tuple__18 __pyx_mstate_global->__pyx_tuple__18 +#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 +#define __pyx_tuple__20 __pyx_mstate_global->__pyx_tuple__20 +#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 +#define __pyx_tuple__22 __pyx_mstate_global->__pyx_tuple__22 +#define __pyx_tuple__23 __pyx_mstate_global->__pyx_tuple__23 +#define __pyx_tuple__24 __pyx_mstate_global->__pyx_tuple__24 +#define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25 +#define __pyx_tuple__26 __pyx_mstate_global->__pyx_tuple__26 +#define __pyx_tuple__27 __pyx_mstate_global->__pyx_tuple__27 +#define __pyx_tuple__28 __pyx_mstate_global->__pyx_tuple__28 +#define __pyx_tuple__29 __pyx_mstate_global->__pyx_tuple__29 +#define __pyx_tuple__30 __pyx_mstate_global->__pyx_tuple__30 +#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31 +#define __pyx_tuple__32 __pyx_mstate_global->__pyx_tuple__32 +#define __pyx_tuple__33 __pyx_mstate_global->__pyx_tuple__33 +#define __pyx_tuple__34 __pyx_mstate_global->__pyx_tuple__34 +#define __pyx_tuple__35 __pyx_mstate_global->__pyx_tuple__35 +#define __pyx_tuple__36 __pyx_mstate_global->__pyx_tuple__36 +#define __pyx_tuple__37 __pyx_mstate_global->__pyx_tuple__37 +#define __pyx_tuple__38 __pyx_mstate_global->__pyx_tuple__38 +#define __pyx_tuple__39 __pyx_mstate_global->__pyx_tuple__39 +#define __pyx_tuple__40 __pyx_mstate_global->__pyx_tuple__40 +#define __pyx_tuple__41 __pyx_mstate_global->__pyx_tuple__41 +#define __pyx_tuple__42 __pyx_mstate_global->__pyx_tuple__42 +#define __pyx_tuple__43 __pyx_mstate_global->__pyx_tuple__43 +#define __pyx_tuple__44 __pyx_mstate_global->__pyx_tuple__44 +#define __pyx_tuple__45 __pyx_mstate_global->__pyx_tuple__45 +#define __pyx_tuple__46 __pyx_mstate_global->__pyx_tuple__46 +#define __pyx_tuple__47 __pyx_mstate_global->__pyx_tuple__47 +#define __pyx_tuple__48 __pyx_mstate_global->__pyx_tuple__48 +#define __pyx_tuple__49 __pyx_mstate_global->__pyx_tuple__49 +#define __pyx_tuple__50 __pyx_mstate_global->__pyx_tuple__50 +#define __pyx_tuple__51 __pyx_mstate_global->__pyx_tuple__51 +#define __pyx_tuple__52 __pyx_mstate_global->__pyx_tuple__52 +#define __pyx_tuple__53 __pyx_mstate_global->__pyx_tuple__53 +#define __pyx_tuple__54 __pyx_mstate_global->__pyx_tuple__54 +#define __pyx_tuple__55 __pyx_mstate_global->__pyx_tuple__55 +#define __pyx_tuple__56 __pyx_mstate_global->__pyx_tuple__56 +#define __pyx_tuple__57 __pyx_mstate_global->__pyx_tuple__57 +#define __pyx_tuple__58 __pyx_mstate_global->__pyx_tuple__58 +#define __pyx_tuple__59 __pyx_mstate_global->__pyx_tuple__59 +#define __pyx_tuple__60 __pyx_mstate_global->__pyx_tuple__60 +#define __pyx_tuple__61 __pyx_mstate_global->__pyx_tuple__61 +#define __pyx_tuple__62 __pyx_mstate_global->__pyx_tuple__62 +#define __pyx_tuple__63 __pyx_mstate_global->__pyx_tuple__63 +#define __pyx_tuple__64 __pyx_mstate_global->__pyx_tuple__64 +#define __pyx_tuple__65 __pyx_mstate_global->__pyx_tuple__65 +#define __pyx_tuple__66 __pyx_mstate_global->__pyx_tuple__66 +#define __pyx_tuple__67 __pyx_mstate_global->__pyx_tuple__67 +#define __pyx_tuple__68 __pyx_mstate_global->__pyx_tuple__68 +#define __pyx_tuple__69 __pyx_mstate_global->__pyx_tuple__69 +#define __pyx_tuple__70 __pyx_mstate_global->__pyx_tuple__70 +#define __pyx_tuple__71 __pyx_mstate_global->__pyx_tuple__71 +#define __pyx_tuple__72 __pyx_mstate_global->__pyx_tuple__72 +#define __pyx_tuple__73 __pyx_mstate_global->__pyx_tuple__73 +#define __pyx_tuple__74 __pyx_mstate_global->__pyx_tuple__74 +#define __pyx_tuple__75 __pyx_mstate_global->__pyx_tuple__75 +#define __pyx_tuple__76 __pyx_mstate_global->__pyx_tuple__76 +#define __pyx_tuple__77 __pyx_mstate_global->__pyx_tuple__77 +#define __pyx_tuple__78 __pyx_mstate_global->__pyx_tuple__78 +#define __pyx_tuple__80 __pyx_mstate_global->__pyx_tuple__80 +#define __pyx_tuple__81 __pyx_mstate_global->__pyx_tuple__81 +#define __pyx_tuple__82 __pyx_mstate_global->__pyx_tuple__82 +#define __pyx_tuple__83 __pyx_mstate_global->__pyx_tuple__83 +#define __pyx_tuple__84 __pyx_mstate_global->__pyx_tuple__84 +#define __pyx_tuple__85 __pyx_mstate_global->__pyx_tuple__85 +#define __pyx_tuple__86 __pyx_mstate_global->__pyx_tuple__86 +#define __pyx_tuple__87 __pyx_mstate_global->__pyx_tuple__87 +#define __pyx_tuple__90 __pyx_mstate_global->__pyx_tuple__90 +#define __pyx_tuple__91 __pyx_mstate_global->__pyx_tuple__91 +#define __pyx_tuple__92 __pyx_mstate_global->__pyx_tuple__92 +#define __pyx_tuple__96 __pyx_mstate_global->__pyx_tuple__96 +#define __pyx_tuple__97 __pyx_mstate_global->__pyx_tuple__97 +#define __pyx_tuple__98 __pyx_mstate_global->__pyx_tuple__98 +#define __pyx_tuple__99 __pyx_mstate_global->__pyx_tuple__99 +#define __pyx_tuple__100 __pyx_mstate_global->__pyx_tuple__100 +#define __pyx_tuple__107 __pyx_mstate_global->__pyx_tuple__107 +#define __pyx_tuple__108 __pyx_mstate_global->__pyx_tuple__108 +#define __pyx_tuple__109 __pyx_mstate_global->__pyx_tuple__109 +#define __pyx_tuple__110 __pyx_mstate_global->__pyx_tuple__110 +#define __pyx_tuple__111 __pyx_mstate_global->__pyx_tuple__111 +#define __pyx_tuple__112 __pyx_mstate_global->__pyx_tuple__112 +#define __pyx_tuple__113 __pyx_mstate_global->__pyx_tuple__113 +#define __pyx_tuple__115 __pyx_mstate_global->__pyx_tuple__115 +#define __pyx_tuple__116 __pyx_mstate_global->__pyx_tuple__116 +#define __pyx_tuple__117 __pyx_mstate_global->__pyx_tuple__117 +#define __pyx_tuple__118 __pyx_mstate_global->__pyx_tuple__118 +#define __pyx_tuple__119 __pyx_mstate_global->__pyx_tuple__119 +#define __pyx_tuple__120 __pyx_mstate_global->__pyx_tuple__120 +#define __pyx_tuple__121 __pyx_mstate_global->__pyx_tuple__121 +#define __pyx_tuple__122 __pyx_mstate_global->__pyx_tuple__122 +#define __pyx_tuple__123 __pyx_mstate_global->__pyx_tuple__123 +#define __pyx_tuple__124 __pyx_mstate_global->__pyx_tuple__124 +#define __pyx_tuple__125 __pyx_mstate_global->__pyx_tuple__125 +#define __pyx_tuple__127 __pyx_mstate_global->__pyx_tuple__127 +#define __pyx_tuple__129 __pyx_mstate_global->__pyx_tuple__129 +#define __pyx_tuple__131 __pyx_mstate_global->__pyx_tuple__131 +#define __pyx_tuple__132 __pyx_mstate_global->__pyx_tuple__132 +#define __pyx_tuple__134 __pyx_mstate_global->__pyx_tuple__134 +#define __pyx_tuple__136 __pyx_mstate_global->__pyx_tuple__136 +#define __pyx_tuple__138 __pyx_mstate_global->__pyx_tuple__138 +#define __pyx_tuple__141 __pyx_mstate_global->__pyx_tuple__141 +#define __pyx_tuple__143 __pyx_mstate_global->__pyx_tuple__143 +#define __pyx_tuple__145 __pyx_mstate_global->__pyx_tuple__145 +#define __pyx_tuple__147 __pyx_mstate_global->__pyx_tuple__147 +#define __pyx_tuple__149 __pyx_mstate_global->__pyx_tuple__149 +#define __pyx_tuple__151 __pyx_mstate_global->__pyx_tuple__151 +#define __pyx_tuple__153 __pyx_mstate_global->__pyx_tuple__153 +#define __pyx_tuple__155 __pyx_mstate_global->__pyx_tuple__155 +#define __pyx_tuple__159 __pyx_mstate_global->__pyx_tuple__159 +#define __pyx_tuple__182 __pyx_mstate_global->__pyx_tuple__182 +#define __pyx_tuple__188 __pyx_mstate_global->__pyx_tuple__188 +#define __pyx_tuple__190 __pyx_mstate_global->__pyx_tuple__190 +#define __pyx_tuple__192 __pyx_mstate_global->__pyx_tuple__192 +#define __pyx_tuple__194 __pyx_mstate_global->__pyx_tuple__194 +#define __pyx_tuple__198 __pyx_mstate_global->__pyx_tuple__198 +#define __pyx_tuple__200 __pyx_mstate_global->__pyx_tuple__200 +#define __pyx_tuple__202 __pyx_mstate_global->__pyx_tuple__202 +#define __pyx_tuple__203 __pyx_mstate_global->__pyx_tuple__203 +#define __pyx_tuple__205 __pyx_mstate_global->__pyx_tuple__205 +#define __pyx_tuple__207 __pyx_mstate_global->__pyx_tuple__207 +#define __pyx_tuple__209 __pyx_mstate_global->__pyx_tuple__209 +#define __pyx_tuple__210 __pyx_mstate_global->__pyx_tuple__210 +#define __pyx_tuple__212 __pyx_mstate_global->__pyx_tuple__212 +#define __pyx_tuple__213 __pyx_mstate_global->__pyx_tuple__213 +#define __pyx_tuple__215 __pyx_mstate_global->__pyx_tuple__215 +#define __pyx_tuple__217 __pyx_mstate_global->__pyx_tuple__217 +#define __pyx_tuple__218 __pyx_mstate_global->__pyx_tuple__218 +#define __pyx_tuple__220 __pyx_mstate_global->__pyx_tuple__220 +#define __pyx_tuple__222 __pyx_mstate_global->__pyx_tuple__222 +#define __pyx_tuple__224 __pyx_mstate_global->__pyx_tuple__224 +#define __pyx_tuple__226 __pyx_mstate_global->__pyx_tuple__226 +#define __pyx_tuple__229 __pyx_mstate_global->__pyx_tuple__229 +#define __pyx_tuple__231 __pyx_mstate_global->__pyx_tuple__231 +#define __pyx_tuple__233 __pyx_mstate_global->__pyx_tuple__233 +#define __pyx_tuple__235 __pyx_mstate_global->__pyx_tuple__235 +#define __pyx_tuple__238 __pyx_mstate_global->__pyx_tuple__238 +#define __pyx_tuple__241 __pyx_mstate_global->__pyx_tuple__241 +#define __pyx_tuple__243 __pyx_mstate_global->__pyx_tuple__243 +#define __pyx_tuple__245 __pyx_mstate_global->__pyx_tuple__245 +#define __pyx_tuple__247 __pyx_mstate_global->__pyx_tuple__247 +#define __pyx_tuple__249 __pyx_mstate_global->__pyx_tuple__249 +#define __pyx_tuple__260 __pyx_mstate_global->__pyx_tuple__260 +#define __pyx_tuple__262 __pyx_mstate_global->__pyx_tuple__262 +#define __pyx_tuple__264 __pyx_mstate_global->__pyx_tuple__264 +#define __pyx_tuple__266 __pyx_mstate_global->__pyx_tuple__266 +#define __pyx_tuple__268 __pyx_mstate_global->__pyx_tuple__268 +#define __pyx_tuple__271 __pyx_mstate_global->__pyx_tuple__271 +#define __pyx_tuple__280 __pyx_mstate_global->__pyx_tuple__280 +#define __pyx_tuple__289 __pyx_mstate_global->__pyx_tuple__289 +#define __pyx_tuple__296 __pyx_mstate_global->__pyx_tuple__296 +#define __pyx_tuple__302 __pyx_mstate_global->__pyx_tuple__302 +#define __pyx_tuple__304 __pyx_mstate_global->__pyx_tuple__304 +#define __pyx_tuple__306 __pyx_mstate_global->__pyx_tuple__306 +#define __pyx_tuple__309 __pyx_mstate_global->__pyx_tuple__309 +#define __pyx_tuple__311 __pyx_mstate_global->__pyx_tuple__311 +#define __pyx_tuple__313 __pyx_mstate_global->__pyx_tuple__313 +#define __pyx_tuple__315 __pyx_mstate_global->__pyx_tuple__315 +#define __pyx_tuple__317 __pyx_mstate_global->__pyx_tuple__317 +#define __pyx_tuple__319 __pyx_mstate_global->__pyx_tuple__319 +#define __pyx_tuple__321 __pyx_mstate_global->__pyx_tuple__321 +#define __pyx_tuple__323 __pyx_mstate_global->__pyx_tuple__323 +#define __pyx_tuple__326 __pyx_mstate_global->__pyx_tuple__326 +#define __pyx_tuple__348 __pyx_mstate_global->__pyx_tuple__348 +#define __pyx_tuple__359 __pyx_mstate_global->__pyx_tuple__359 +#define __pyx_tuple__368 __pyx_mstate_global->__pyx_tuple__368 +#define __pyx_tuple__377 __pyx_mstate_global->__pyx_tuple__377 +#define __pyx_tuple__394 __pyx_mstate_global->__pyx_tuple__394 +#define __pyx_tuple__398 __pyx_mstate_global->__pyx_tuple__398 +#define __pyx_tuple__400 __pyx_mstate_global->__pyx_tuple__400 +#define __pyx_tuple__402 __pyx_mstate_global->__pyx_tuple__402 +#define __pyx_tuple__412 __pyx_mstate_global->__pyx_tuple__412 +#define __pyx_tuple__418 __pyx_mstate_global->__pyx_tuple__418 +#define __pyx_tuple__436 __pyx_mstate_global->__pyx_tuple__436 +#define __pyx_tuple__440 __pyx_mstate_global->__pyx_tuple__440 +#define __pyx_tuple__471 __pyx_mstate_global->__pyx_tuple__471 +#define __pyx_tuple__475 __pyx_mstate_global->__pyx_tuple__475 +#define __pyx_tuple__479 __pyx_mstate_global->__pyx_tuple__479 +#define __pyx_tuple__481 __pyx_mstate_global->__pyx_tuple__481 +#define __pyx_tuple__483 __pyx_mstate_global->__pyx_tuple__483 +#define __pyx_tuple__488 __pyx_mstate_global->__pyx_tuple__488 +#define __pyx_tuple__509 __pyx_mstate_global->__pyx_tuple__509 +#define __pyx_tuple__513 __pyx_mstate_global->__pyx_tuple__513 +#define __pyx_tuple__515 __pyx_mstate_global->__pyx_tuple__515 +#define __pyx_tuple__521 __pyx_mstate_global->__pyx_tuple__521 +#define __pyx_tuple__528 __pyx_mstate_global->__pyx_tuple__528 +#define __pyx_tuple__530 __pyx_mstate_global->__pyx_tuple__530 +#define __pyx_tuple__541 __pyx_mstate_global->__pyx_tuple__541 +#define __pyx_tuple__551 __pyx_mstate_global->__pyx_tuple__551 +#define __pyx_tuple__556 __pyx_mstate_global->__pyx_tuple__556 +#define __pyx_tuple__558 __pyx_mstate_global->__pyx_tuple__558 +#define __pyx_tuple__560 __pyx_mstate_global->__pyx_tuple__560 +#define __pyx_tuple__562 __pyx_mstate_global->__pyx_tuple__562 +#define __pyx_tuple__567 __pyx_mstate_global->__pyx_tuple__567 +#define __pyx_tuple__572 __pyx_mstate_global->__pyx_tuple__572 +#define __pyx_tuple__596 __pyx_mstate_global->__pyx_tuple__596 +#define __pyx_tuple__602 __pyx_mstate_global->__pyx_tuple__602 +#define __pyx_tuple__604 __pyx_mstate_global->__pyx_tuple__604 +#define __pyx_tuple__607 __pyx_mstate_global->__pyx_tuple__607 +#define __pyx_tuple__609 __pyx_mstate_global->__pyx_tuple__609 +#define __pyx_tuple__611 __pyx_mstate_global->__pyx_tuple__611 +#define __pyx_tuple__614 __pyx_mstate_global->__pyx_tuple__614 +#define __pyx_tuple__636 __pyx_mstate_global->__pyx_tuple__636 +#define __pyx_tuple__644 __pyx_mstate_global->__pyx_tuple__644 +#define __pyx_tuple__651 __pyx_mstate_global->__pyx_tuple__651 +#define __pyx_tuple__653 __pyx_mstate_global->__pyx_tuple__653 +#define __pyx_tuple__654 __pyx_mstate_global->__pyx_tuple__654 +#define __pyx_tuple__656 __pyx_mstate_global->__pyx_tuple__656 +#define __pyx_tuple__660 __pyx_mstate_global->__pyx_tuple__660 +#define __pyx_tuple__663 __pyx_mstate_global->__pyx_tuple__663 +#define __pyx_tuple__665 __pyx_mstate_global->__pyx_tuple__665 +#define __pyx_tuple__666 __pyx_mstate_global->__pyx_tuple__666 +#define __pyx_tuple__668 __pyx_mstate_global->__pyx_tuple__668 +#define __pyx_tuple__670 __pyx_mstate_global->__pyx_tuple__670 +#define __pyx_tuple__674 __pyx_mstate_global->__pyx_tuple__674 +#define __pyx_tuple__676 __pyx_mstate_global->__pyx_tuple__676 +#define __pyx_tuple__680 __pyx_mstate_global->__pyx_tuple__680 +#define __pyx_tuple__682 __pyx_mstate_global->__pyx_tuple__682 +#define __pyx_tuple__684 __pyx_mstate_global->__pyx_tuple__684 +#define __pyx_tuple__685 __pyx_mstate_global->__pyx_tuple__685 +#define __pyx_tuple__687 __pyx_mstate_global->__pyx_tuple__687 +#define __pyx_tuple__688 __pyx_mstate_global->__pyx_tuple__688 +#define __pyx_tuple__690 __pyx_mstate_global->__pyx_tuple__690 +#define __pyx_tuple__692 __pyx_mstate_global->__pyx_tuple__692 +#define __pyx_tuple__694 __pyx_mstate_global->__pyx_tuple__694 +#define __pyx_tuple__696 __pyx_mstate_global->__pyx_tuple__696 +#define __pyx_tuple__698 __pyx_mstate_global->__pyx_tuple__698 +#define __pyx_tuple__702 __pyx_mstate_global->__pyx_tuple__702 +#define __pyx_tuple__704 __pyx_mstate_global->__pyx_tuple__704 +#define __pyx_tuple__708 __pyx_mstate_global->__pyx_tuple__708 +#define __pyx_tuple__710 __pyx_mstate_global->__pyx_tuple__710 +#define __pyx_tuple__712 __pyx_mstate_global->__pyx_tuple__712 +#define __pyx_tuple__714 __pyx_mstate_global->__pyx_tuple__714 +#define __pyx_tuple__716 __pyx_mstate_global->__pyx_tuple__716 +#define __pyx_tuple__720 __pyx_mstate_global->__pyx_tuple__720 +#define __pyx_tuple__722 __pyx_mstate_global->__pyx_tuple__722 +#define __pyx_tuple__730 __pyx_mstate_global->__pyx_tuple__730 +#define __pyx_tuple__734 __pyx_mstate_global->__pyx_tuple__734 +#define __pyx_tuple__737 __pyx_mstate_global->__pyx_tuple__737 +#define __pyx_tuple__739 __pyx_mstate_global->__pyx_tuple__739 +#define __pyx_tuple__743 __pyx_mstate_global->__pyx_tuple__743 +#define __pyx_tuple__745 __pyx_mstate_global->__pyx_tuple__745 +#define __pyx_tuple__747 __pyx_mstate_global->__pyx_tuple__747 +#define __pyx_tuple__750 __pyx_mstate_global->__pyx_tuple__750 +#define __pyx_tuple__752 __pyx_mstate_global->__pyx_tuple__752 +#define __pyx_tuple__753 __pyx_mstate_global->__pyx_tuple__753 +#define __pyx_tuple__760 __pyx_mstate_global->__pyx_tuple__760 +#define __pyx_tuple__765 __pyx_mstate_global->__pyx_tuple__765 +#define __pyx_tuple__767 __pyx_mstate_global->__pyx_tuple__767 +#define __pyx_tuple__770 __pyx_mstate_global->__pyx_tuple__770 +#define __pyx_tuple__772 __pyx_mstate_global->__pyx_tuple__772 +#define __pyx_tuple__775 __pyx_mstate_global->__pyx_tuple__775 +#define __pyx_tuple__780 __pyx_mstate_global->__pyx_tuple__780 +#define __pyx_tuple__782 __pyx_mstate_global->__pyx_tuple__782 +#define __pyx_tuple__783 __pyx_mstate_global->__pyx_tuple__783 +#define __pyx_tuple__785 __pyx_mstate_global->__pyx_tuple__785 +#define __pyx_tuple__787 __pyx_mstate_global->__pyx_tuple__787 +#define __pyx_tuple__789 __pyx_mstate_global->__pyx_tuple__789 +#define __pyx_tuple__791 __pyx_mstate_global->__pyx_tuple__791 +#define __pyx_tuple__793 __pyx_mstate_global->__pyx_tuple__793 +#define __pyx_tuple__794 __pyx_mstate_global->__pyx_tuple__794 +#define __pyx_tuple__796 __pyx_mstate_global->__pyx_tuple__796 +#define __pyx_tuple__798 __pyx_mstate_global->__pyx_tuple__798 +#define __pyx_tuple__800 __pyx_mstate_global->__pyx_tuple__800 +#define __pyx_tuple__801 __pyx_mstate_global->__pyx_tuple__801 +#define __pyx_tuple__803 __pyx_mstate_global->__pyx_tuple__803 +#define __pyx_tuple__805 __pyx_mstate_global->__pyx_tuple__805 +#define __pyx_tuple__808 __pyx_mstate_global->__pyx_tuple__808 +#define __pyx_tuple__810 __pyx_mstate_global->__pyx_tuple__810 +#define __pyx_tuple__812 __pyx_mstate_global->__pyx_tuple__812 +#define __pyx_tuple__814 __pyx_mstate_global->__pyx_tuple__814 +#define __pyx_tuple__816 __pyx_mstate_global->__pyx_tuple__816 +#define __pyx_tuple__818 __pyx_mstate_global->__pyx_tuple__818 +#define __pyx_tuple__820 __pyx_mstate_global->__pyx_tuple__820 +#define __pyx_tuple__821 __pyx_mstate_global->__pyx_tuple__821 +#define __pyx_tuple__823 __pyx_mstate_global->__pyx_tuple__823 +#define __pyx_tuple__825 __pyx_mstate_global->__pyx_tuple__825 +#define __pyx_tuple__826 __pyx_mstate_global->__pyx_tuple__826 +#define __pyx_tuple__828 __pyx_mstate_global->__pyx_tuple__828 +#define __pyx_tuple__829 __pyx_mstate_global->__pyx_tuple__829 +#define __pyx_tuple__831 __pyx_mstate_global->__pyx_tuple__831 +#define __pyx_tuple__832 __pyx_mstate_global->__pyx_tuple__832 +#define __pyx_tuple__834 __pyx_mstate_global->__pyx_tuple__834 +#define __pyx_tuple__835 __pyx_mstate_global->__pyx_tuple__835 +#define __pyx_tuple__837 __pyx_mstate_global->__pyx_tuple__837 +#define __pyx_tuple__839 __pyx_mstate_global->__pyx_tuple__839 +#define __pyx_tuple__844 __pyx_mstate_global->__pyx_tuple__844 +#define __pyx_tuple__846 __pyx_mstate_global->__pyx_tuple__846 +#define __pyx_tuple__848 __pyx_mstate_global->__pyx_tuple__848 +#define __pyx_tuple__850 __pyx_mstate_global->__pyx_tuple__850 +#define __pyx_tuple__852 __pyx_mstate_global->__pyx_tuple__852 +#define __pyx_tuple__854 __pyx_mstate_global->__pyx_tuple__854 +#define __pyx_tuple__856 __pyx_mstate_global->__pyx_tuple__856 +#define __pyx_tuple__859 __pyx_mstate_global->__pyx_tuple__859 +#define __pyx_tuple__863 __pyx_mstate_global->__pyx_tuple__863 +#define __pyx_tuple__865 __pyx_mstate_global->__pyx_tuple__865 +#define __pyx_tuple__867 __pyx_mstate_global->__pyx_tuple__867 +#define __pyx_tuple__871 __pyx_mstate_global->__pyx_tuple__871 +#define __pyx_tuple__873 __pyx_mstate_global->__pyx_tuple__873 +#define __pyx_tuple__875 __pyx_mstate_global->__pyx_tuple__875 +#define __pyx_tuple__877 __pyx_mstate_global->__pyx_tuple__877 +#define __pyx_tuple__879 __pyx_mstate_global->__pyx_tuple__879 +#define __pyx_tuple__881 __pyx_mstate_global->__pyx_tuple__881 +#define __pyx_tuple__883 __pyx_mstate_global->__pyx_tuple__883 +#define __pyx_tuple__885 __pyx_mstate_global->__pyx_tuple__885 +#define __pyx_tuple__887 __pyx_mstate_global->__pyx_tuple__887 +#define __pyx_tuple__892 __pyx_mstate_global->__pyx_tuple__892 +#define __pyx_tuple__894 __pyx_mstate_global->__pyx_tuple__894 +#define __pyx_tuple__896 __pyx_mstate_global->__pyx_tuple__896 +#define __pyx_tuple__900 __pyx_mstate_global->__pyx_tuple__900 +#define __pyx_tuple__902 __pyx_mstate_global->__pyx_tuple__902 +#define __pyx_tuple__907 __pyx_mstate_global->__pyx_tuple__907 +#define __pyx_tuple__909 __pyx_mstate_global->__pyx_tuple__909 +#define __pyx_tuple__911 __pyx_mstate_global->__pyx_tuple__911 +#define __pyx_tuple__913 __pyx_mstate_global->__pyx_tuple__913 +#define __pyx_tuple__915 __pyx_mstate_global->__pyx_tuple__915 +#define __pyx_tuple__917 __pyx_mstate_global->__pyx_tuple__917 +#define __pyx_tuple__919 __pyx_mstate_global->__pyx_tuple__919 +#define __pyx_tuple__921 __pyx_mstate_global->__pyx_tuple__921 +#define __pyx_tuple__923 __pyx_mstate_global->__pyx_tuple__923 +#define __pyx_tuple__925 __pyx_mstate_global->__pyx_tuple__925 +#define __pyx_tuple__927 __pyx_mstate_global->__pyx_tuple__927 +#define __pyx_tuple__929 __pyx_mstate_global->__pyx_tuple__929 +#define __pyx_tuple__930 __pyx_mstate_global->__pyx_tuple__930 +#define __pyx_tuple__932 __pyx_mstate_global->__pyx_tuple__932 +#define __pyx_tuple__934 __pyx_mstate_global->__pyx_tuple__934 +#define __pyx_tuple__936 __pyx_mstate_global->__pyx_tuple__936 +#define __pyx_tuple__938 __pyx_mstate_global->__pyx_tuple__938 +#define __pyx_tuple__940 __pyx_mstate_global->__pyx_tuple__940 +#define __pyx_tuple__941 __pyx_mstate_global->__pyx_tuple__941 +#define __pyx_tuple__943 __pyx_mstate_global->__pyx_tuple__943 +#define __pyx_tuple__945 __pyx_mstate_global->__pyx_tuple__945 +#define __pyx_tuple__946 __pyx_mstate_global->__pyx_tuple__946 +#define __pyx_tuple__948 __pyx_mstate_global->__pyx_tuple__948 +#define __pyx_tuple__950 __pyx_mstate_global->__pyx_tuple__950 +#define __pyx_tuple__951 __pyx_mstate_global->__pyx_tuple__951 +#define __pyx_tuple__953 __pyx_mstate_global->__pyx_tuple__953 +#define __pyx_tuple__955 __pyx_mstate_global->__pyx_tuple__955 +#define __pyx_tuple__957 __pyx_mstate_global->__pyx_tuple__957 +#define __pyx_tuple__959 __pyx_mstate_global->__pyx_tuple__959 +#define __pyx_tuple__960 __pyx_mstate_global->__pyx_tuple__960 +#define __pyx_tuple__962 __pyx_mstate_global->__pyx_tuple__962 +#define __pyx_tuple__964 __pyx_mstate_global->__pyx_tuple__964 +#define __pyx_tuple__966 __pyx_mstate_global->__pyx_tuple__966 +#define __pyx_tuple__968 __pyx_mstate_global->__pyx_tuple__968 +#define __pyx_tuple__969 __pyx_mstate_global->__pyx_tuple__969 +#define __pyx_tuple__971 __pyx_mstate_global->__pyx_tuple__971 +#define __pyx_tuple__973 __pyx_mstate_global->__pyx_tuple__973 +#define __pyx_tuple__975 __pyx_mstate_global->__pyx_tuple__975 +#define __pyx_tuple__977 __pyx_mstate_global->__pyx_tuple__977 +#define __pyx_tuple__979 __pyx_mstate_global->__pyx_tuple__979 +#define __pyx_tuple__981 __pyx_mstate_global->__pyx_tuple__981 +#define __pyx_tuple__983 __pyx_mstate_global->__pyx_tuple__983 +#define __pyx_tuple__987 __pyx_mstate_global->__pyx_tuple__987 +#define __pyx_tuple__989 __pyx_mstate_global->__pyx_tuple__989 +#define __pyx_tuple__994 __pyx_mstate_global->__pyx_tuple__994 +#define __pyx_tuple__996 __pyx_mstate_global->__pyx_tuple__996 +#define __pyx_tuple__999 __pyx_mstate_global->__pyx_tuple__999 +#define __pyx_codeobj__93 __pyx_mstate_global->__pyx_codeobj__93 +#define __pyx_codeobj__95 __pyx_mstate_global->__pyx_codeobj__95 +#define __pyx_tuple__1001 __pyx_mstate_global->__pyx_tuple__1001 +#define __pyx_tuple__1006 __pyx_mstate_global->__pyx_tuple__1006 +#define __pyx_tuple__1012 __pyx_mstate_global->__pyx_tuple__1012 +#define __pyx_tuple__1018 __pyx_mstate_global->__pyx_tuple__1018 +#define __pyx_tuple__1022 __pyx_mstate_global->__pyx_tuple__1022 +#define __pyx_tuple__1024 __pyx_mstate_global->__pyx_tuple__1024 +#define __pyx_tuple__1025 __pyx_mstate_global->__pyx_tuple__1025 +#define __pyx_tuple__1027 __pyx_mstate_global->__pyx_tuple__1027 +#define __pyx_tuple__1030 __pyx_mstate_global->__pyx_tuple__1030 +#define __pyx_tuple__1032 __pyx_mstate_global->__pyx_tuple__1032 +#define __pyx_tuple__1034 __pyx_mstate_global->__pyx_tuple__1034 +#define __pyx_tuple__1035 __pyx_mstate_global->__pyx_tuple__1035 +#define __pyx_tuple__1037 __pyx_mstate_global->__pyx_tuple__1037 +#define __pyx_tuple__1039 __pyx_mstate_global->__pyx_tuple__1039 +#define __pyx_tuple__1040 __pyx_mstate_global->__pyx_tuple__1040 +#define __pyx_tuple__1044 __pyx_mstate_global->__pyx_tuple__1044 +#define __pyx_tuple__1046 __pyx_mstate_global->__pyx_tuple__1046 +#define __pyx_tuple__1048 __pyx_mstate_global->__pyx_tuple__1048 +#define __pyx_tuple__1050 __pyx_mstate_global->__pyx_tuple__1050 +#define __pyx_tuple__1051 __pyx_mstate_global->__pyx_tuple__1051 +#define __pyx_tuple__1053 __pyx_mstate_global->__pyx_tuple__1053 +#define __pyx_tuple__1054 __pyx_mstate_global->__pyx_tuple__1054 +#define __pyx_tuple__1061 __pyx_mstate_global->__pyx_tuple__1061 +#define __pyx_tuple__1064 __pyx_mstate_global->__pyx_tuple__1064 +#define __pyx_tuple__1066 __pyx_mstate_global->__pyx_tuple__1066 +#define __pyx_tuple__1069 __pyx_mstate_global->__pyx_tuple__1069 +#define __pyx_tuple__1071 __pyx_mstate_global->__pyx_tuple__1071 +#define __pyx_tuple__1075 __pyx_mstate_global->__pyx_tuple__1075 +#define __pyx_tuple__1080 __pyx_mstate_global->__pyx_tuple__1080 +#define __pyx_tuple__1086 __pyx_mstate_global->__pyx_tuple__1086 +#define __pyx_tuple__1088 __pyx_mstate_global->__pyx_tuple__1088 +#define __pyx_tuple__1091 __pyx_mstate_global->__pyx_tuple__1091 +#define __pyx_tuple__1094 __pyx_mstate_global->__pyx_tuple__1094 +#define __pyx_tuple__1098 __pyx_mstate_global->__pyx_tuple__1098 +#define __pyx_tuple__1100 __pyx_mstate_global->__pyx_tuple__1100 +#define __pyx_tuple__1102 __pyx_mstate_global->__pyx_tuple__1102 +#define __pyx_tuple__1104 __pyx_mstate_global->__pyx_tuple__1104 +#define __pyx_tuple__1106 __pyx_mstate_global->__pyx_tuple__1106 +#define __pyx_tuple__1108 __pyx_mstate_global->__pyx_tuple__1108 +#define __pyx_tuple__1114 __pyx_mstate_global->__pyx_tuple__1114 +#define __pyx_tuple__1116 __pyx_mstate_global->__pyx_tuple__1116 +#define __pyx_tuple__1118 __pyx_mstate_global->__pyx_tuple__1118 +#define __pyx_tuple__1120 __pyx_mstate_global->__pyx_tuple__1120 +#define __pyx_tuple__1122 __pyx_mstate_global->__pyx_tuple__1122 +#define __pyx_tuple__1124 __pyx_mstate_global->__pyx_tuple__1124 +#define __pyx_tuple__1126 __pyx_mstate_global->__pyx_tuple__1126 +#define __pyx_tuple__1128 __pyx_mstate_global->__pyx_tuple__1128 +#define __pyx_tuple__1131 __pyx_mstate_global->__pyx_tuple__1131 +#define __pyx_tuple__1133 __pyx_mstate_global->__pyx_tuple__1133 +#define __pyx_tuple__1137 __pyx_mstate_global->__pyx_tuple__1137 +#define __pyx_tuple__1141 __pyx_mstate_global->__pyx_tuple__1141 +#define __pyx_tuple__1143 __pyx_mstate_global->__pyx_tuple__1143 +#define __pyx_tuple__1144 __pyx_mstate_global->__pyx_tuple__1144 +#define __pyx_tuple__1151 __pyx_mstate_global->__pyx_tuple__1151 +#define __pyx_codeobj__128 __pyx_mstate_global->__pyx_codeobj__128 +#define __pyx_codeobj__130 __pyx_mstate_global->__pyx_codeobj__130 +#define __pyx_codeobj__133 __pyx_mstate_global->__pyx_codeobj__133 +#define __pyx_codeobj__135 __pyx_mstate_global->__pyx_codeobj__135 +#define __pyx_codeobj__137 __pyx_mstate_global->__pyx_codeobj__137 +#define __pyx_codeobj__139 __pyx_mstate_global->__pyx_codeobj__139 +#define __pyx_codeobj__140 __pyx_mstate_global->__pyx_codeobj__140 +#define __pyx_codeobj__142 __pyx_mstate_global->__pyx_codeobj__142 +#define __pyx_codeobj__144 __pyx_mstate_global->__pyx_codeobj__144 +#define __pyx_codeobj__146 __pyx_mstate_global->__pyx_codeobj__146 +#define __pyx_codeobj__148 __pyx_mstate_global->__pyx_codeobj__148 +#define __pyx_codeobj__150 __pyx_mstate_global->__pyx_codeobj__150 +#define __pyx_codeobj__152 __pyx_mstate_global->__pyx_codeobj__152 +#define __pyx_codeobj__154 __pyx_mstate_global->__pyx_codeobj__154 +#define __pyx_codeobj__156 __pyx_mstate_global->__pyx_codeobj__156 +#define __pyx_codeobj__157 __pyx_mstate_global->__pyx_codeobj__157 +#define __pyx_codeobj__158 __pyx_mstate_global->__pyx_codeobj__158 +#define __pyx_codeobj__160 __pyx_mstate_global->__pyx_codeobj__160 +#define __pyx_codeobj__161 __pyx_mstate_global->__pyx_codeobj__161 +#define __pyx_codeobj__166 __pyx_mstate_global->__pyx_codeobj__166 +#define __pyx_codeobj__167 __pyx_mstate_global->__pyx_codeobj__167 +#define __pyx_codeobj__168 __pyx_mstate_global->__pyx_codeobj__168 +#define __pyx_codeobj__169 __pyx_mstate_global->__pyx_codeobj__169 +#define __pyx_codeobj__170 __pyx_mstate_global->__pyx_codeobj__170 +#define __pyx_codeobj__171 __pyx_mstate_global->__pyx_codeobj__171 +#define __pyx_codeobj__172 __pyx_mstate_global->__pyx_codeobj__172 +#define __pyx_codeobj__173 __pyx_mstate_global->__pyx_codeobj__173 +#define __pyx_codeobj__174 __pyx_mstate_global->__pyx_codeobj__174 +#define __pyx_codeobj__175 __pyx_mstate_global->__pyx_codeobj__175 +#define __pyx_codeobj__176 __pyx_mstate_global->__pyx_codeobj__176 +#define __pyx_codeobj__177 __pyx_mstate_global->__pyx_codeobj__177 +#define __pyx_codeobj__178 __pyx_mstate_global->__pyx_codeobj__178 +#define __pyx_codeobj__179 __pyx_mstate_global->__pyx_codeobj__179 +#define __pyx_codeobj__180 __pyx_mstate_global->__pyx_codeobj__180 +#define __pyx_codeobj__181 __pyx_mstate_global->__pyx_codeobj__181 +#define __pyx_codeobj__183 __pyx_mstate_global->__pyx_codeobj__183 +#define __pyx_codeobj__184 __pyx_mstate_global->__pyx_codeobj__184 +#define __pyx_codeobj__185 __pyx_mstate_global->__pyx_codeobj__185 +#define __pyx_codeobj__186 __pyx_mstate_global->__pyx_codeobj__186 +#define __pyx_codeobj__187 __pyx_mstate_global->__pyx_codeobj__187 +#define __pyx_codeobj__189 __pyx_mstate_global->__pyx_codeobj__189 +#define __pyx_codeobj__191 __pyx_mstate_global->__pyx_codeobj__191 +#define __pyx_codeobj__193 __pyx_mstate_global->__pyx_codeobj__193 +#define __pyx_codeobj__195 __pyx_mstate_global->__pyx_codeobj__195 +#define __pyx_codeobj__196 __pyx_mstate_global->__pyx_codeobj__196 +#define __pyx_codeobj__197 __pyx_mstate_global->__pyx_codeobj__197 +#define __pyx_codeobj__199 __pyx_mstate_global->__pyx_codeobj__199 +#define __pyx_codeobj__201 __pyx_mstate_global->__pyx_codeobj__201 +#define __pyx_codeobj__204 __pyx_mstate_global->__pyx_codeobj__204 +#define __pyx_codeobj__206 __pyx_mstate_global->__pyx_codeobj__206 +#define __pyx_codeobj__208 __pyx_mstate_global->__pyx_codeobj__208 +#define __pyx_codeobj__211 __pyx_mstate_global->__pyx_codeobj__211 +#define __pyx_codeobj__214 __pyx_mstate_global->__pyx_codeobj__214 +#define __pyx_codeobj__216 __pyx_mstate_global->__pyx_codeobj__216 +#define __pyx_codeobj__219 __pyx_mstate_global->__pyx_codeobj__219 +#define __pyx_codeobj__221 __pyx_mstate_global->__pyx_codeobj__221 +#define __pyx_codeobj__223 __pyx_mstate_global->__pyx_codeobj__223 +#define __pyx_codeobj__225 __pyx_mstate_global->__pyx_codeobj__225 +#define __pyx_codeobj__227 __pyx_mstate_global->__pyx_codeobj__227 +#define __pyx_codeobj__228 __pyx_mstate_global->__pyx_codeobj__228 +#define __pyx_codeobj__230 __pyx_mstate_global->__pyx_codeobj__230 +#define __pyx_codeobj__232 __pyx_mstate_global->__pyx_codeobj__232 +#define __pyx_codeobj__234 __pyx_mstate_global->__pyx_codeobj__234 +#define __pyx_codeobj__236 __pyx_mstate_global->__pyx_codeobj__236 +#define __pyx_codeobj__237 __pyx_mstate_global->__pyx_codeobj__237 +#define __pyx_codeobj__239 __pyx_mstate_global->__pyx_codeobj__239 +#define __pyx_codeobj__240 __pyx_mstate_global->__pyx_codeobj__240 +#define __pyx_codeobj__242 __pyx_mstate_global->__pyx_codeobj__242 +#define __pyx_codeobj__244 __pyx_mstate_global->__pyx_codeobj__244 +#define __pyx_codeobj__246 __pyx_mstate_global->__pyx_codeobj__246 +#define __pyx_codeobj__248 __pyx_mstate_global->__pyx_codeobj__248 +#define __pyx_codeobj__250 __pyx_mstate_global->__pyx_codeobj__250 +#define __pyx_codeobj__251 __pyx_mstate_global->__pyx_codeobj__251 +#define __pyx_codeobj__252 __pyx_mstate_global->__pyx_codeobj__252 +#define __pyx_codeobj__253 __pyx_mstate_global->__pyx_codeobj__253 +#define __pyx_codeobj__254 __pyx_mstate_global->__pyx_codeobj__254 +#define __pyx_codeobj__255 __pyx_mstate_global->__pyx_codeobj__255 +#define __pyx_codeobj__256 __pyx_mstate_global->__pyx_codeobj__256 +#define __pyx_codeobj__257 __pyx_mstate_global->__pyx_codeobj__257 +#define __pyx_codeobj__258 __pyx_mstate_global->__pyx_codeobj__258 +#define __pyx_codeobj__259 __pyx_mstate_global->__pyx_codeobj__259 +#define __pyx_codeobj__261 __pyx_mstate_global->__pyx_codeobj__261 +#define __pyx_codeobj__263 __pyx_mstate_global->__pyx_codeobj__263 +#define __pyx_codeobj__265 __pyx_mstate_global->__pyx_codeobj__265 +#define __pyx_codeobj__267 __pyx_mstate_global->__pyx_codeobj__267 +#define __pyx_codeobj__269 __pyx_mstate_global->__pyx_codeobj__269 +#define __pyx_codeobj__270 __pyx_mstate_global->__pyx_codeobj__270 +#define __pyx_codeobj__272 __pyx_mstate_global->__pyx_codeobj__272 +#define __pyx_codeobj__273 __pyx_mstate_global->__pyx_codeobj__273 +#define __pyx_codeobj__274 __pyx_mstate_global->__pyx_codeobj__274 +#define __pyx_codeobj__275 __pyx_mstate_global->__pyx_codeobj__275 +#define __pyx_codeobj__276 __pyx_mstate_global->__pyx_codeobj__276 +#define __pyx_codeobj__277 __pyx_mstate_global->__pyx_codeobj__277 +#define __pyx_codeobj__278 __pyx_mstate_global->__pyx_codeobj__278 +#define __pyx_codeobj__279 __pyx_mstate_global->__pyx_codeobj__279 +#define __pyx_codeobj__281 __pyx_mstate_global->__pyx_codeobj__281 +#define __pyx_codeobj__282 __pyx_mstate_global->__pyx_codeobj__282 +#define __pyx_codeobj__283 __pyx_mstate_global->__pyx_codeobj__283 +#define __pyx_codeobj__284 __pyx_mstate_global->__pyx_codeobj__284 +#define __pyx_codeobj__285 __pyx_mstate_global->__pyx_codeobj__285 +#define __pyx_codeobj__286 __pyx_mstate_global->__pyx_codeobj__286 +#define __pyx_codeobj__287 __pyx_mstate_global->__pyx_codeobj__287 +#define __pyx_codeobj__288 __pyx_mstate_global->__pyx_codeobj__288 +#define __pyx_codeobj__290 __pyx_mstate_global->__pyx_codeobj__290 +#define __pyx_codeobj__291 __pyx_mstate_global->__pyx_codeobj__291 +#define __pyx_codeobj__292 __pyx_mstate_global->__pyx_codeobj__292 +#define __pyx_codeobj__293 __pyx_mstate_global->__pyx_codeobj__293 +#define __pyx_codeobj__294 __pyx_mstate_global->__pyx_codeobj__294 +#define __pyx_codeobj__295 __pyx_mstate_global->__pyx_codeobj__295 +#define __pyx_codeobj__297 __pyx_mstate_global->__pyx_codeobj__297 +#define __pyx_codeobj__298 __pyx_mstate_global->__pyx_codeobj__298 +#define __pyx_codeobj__299 __pyx_mstate_global->__pyx_codeobj__299 +#define __pyx_codeobj__300 __pyx_mstate_global->__pyx_codeobj__300 +#define __pyx_codeobj__301 __pyx_mstate_global->__pyx_codeobj__301 +#define __pyx_codeobj__303 __pyx_mstate_global->__pyx_codeobj__303 +#define __pyx_codeobj__305 __pyx_mstate_global->__pyx_codeobj__305 +#define __pyx_codeobj__307 __pyx_mstate_global->__pyx_codeobj__307 +#define __pyx_codeobj__308 __pyx_mstate_global->__pyx_codeobj__308 +#define __pyx_codeobj__310 __pyx_mstate_global->__pyx_codeobj__310 +#define __pyx_codeobj__312 __pyx_mstate_global->__pyx_codeobj__312 +#define __pyx_codeobj__314 __pyx_mstate_global->__pyx_codeobj__314 +#define __pyx_codeobj__316 __pyx_mstate_global->__pyx_codeobj__316 +#define __pyx_codeobj__318 __pyx_mstate_global->__pyx_codeobj__318 +#define __pyx_codeobj__320 __pyx_mstate_global->__pyx_codeobj__320 +#define __pyx_codeobj__322 __pyx_mstate_global->__pyx_codeobj__322 +#define __pyx_codeobj__324 __pyx_mstate_global->__pyx_codeobj__324 +#define __pyx_codeobj__325 __pyx_mstate_global->__pyx_codeobj__325 +#define __pyx_codeobj__327 __pyx_mstate_global->__pyx_codeobj__327 +#define __pyx_codeobj__328 __pyx_mstate_global->__pyx_codeobj__328 +#define __pyx_codeobj__329 __pyx_mstate_global->__pyx_codeobj__329 +#define __pyx_codeobj__330 __pyx_mstate_global->__pyx_codeobj__330 +#define __pyx_codeobj__331 __pyx_mstate_global->__pyx_codeobj__331 +#define __pyx_codeobj__332 __pyx_mstate_global->__pyx_codeobj__332 +#define __pyx_codeobj__333 __pyx_mstate_global->__pyx_codeobj__333 +#define __pyx_codeobj__334 __pyx_mstate_global->__pyx_codeobj__334 +#define __pyx_codeobj__335 __pyx_mstate_global->__pyx_codeobj__335 +#define __pyx_codeobj__336 __pyx_mstate_global->__pyx_codeobj__336 +#define __pyx_codeobj__337 __pyx_mstate_global->__pyx_codeobj__337 +#define __pyx_codeobj__338 __pyx_mstate_global->__pyx_codeobj__338 +#define __pyx_codeobj__339 __pyx_mstate_global->__pyx_codeobj__339 +#define __pyx_codeobj__340 __pyx_mstate_global->__pyx_codeobj__340 +#define __pyx_codeobj__341 __pyx_mstate_global->__pyx_codeobj__341 +#define __pyx_codeobj__342 __pyx_mstate_global->__pyx_codeobj__342 +#define __pyx_codeobj__343 __pyx_mstate_global->__pyx_codeobj__343 +#define __pyx_codeobj__344 __pyx_mstate_global->__pyx_codeobj__344 +#define __pyx_codeobj__345 __pyx_mstate_global->__pyx_codeobj__345 +#define __pyx_codeobj__346 __pyx_mstate_global->__pyx_codeobj__346 +#define __pyx_codeobj__347 __pyx_mstate_global->__pyx_codeobj__347 +#define __pyx_codeobj__349 __pyx_mstate_global->__pyx_codeobj__349 +#define __pyx_codeobj__350 __pyx_mstate_global->__pyx_codeobj__350 +#define __pyx_codeobj__351 __pyx_mstate_global->__pyx_codeobj__351 +#define __pyx_codeobj__352 __pyx_mstate_global->__pyx_codeobj__352 +#define __pyx_codeobj__353 __pyx_mstate_global->__pyx_codeobj__353 +#define __pyx_codeobj__354 __pyx_mstate_global->__pyx_codeobj__354 +#define __pyx_codeobj__355 __pyx_mstate_global->__pyx_codeobj__355 +#define __pyx_codeobj__356 __pyx_mstate_global->__pyx_codeobj__356 +#define __pyx_codeobj__357 __pyx_mstate_global->__pyx_codeobj__357 +#define __pyx_codeobj__358 __pyx_mstate_global->__pyx_codeobj__358 +#define __pyx_codeobj__360 __pyx_mstate_global->__pyx_codeobj__360 +#define __pyx_codeobj__361 __pyx_mstate_global->__pyx_codeobj__361 +#define __pyx_codeobj__362 __pyx_mstate_global->__pyx_codeobj__362 +#define __pyx_codeobj__363 __pyx_mstate_global->__pyx_codeobj__363 +#define __pyx_codeobj__364 __pyx_mstate_global->__pyx_codeobj__364 +#define __pyx_codeobj__365 __pyx_mstate_global->__pyx_codeobj__365 +#define __pyx_codeobj__366 __pyx_mstate_global->__pyx_codeobj__366 +#define __pyx_codeobj__367 __pyx_mstate_global->__pyx_codeobj__367 +#define __pyx_codeobj__369 __pyx_mstate_global->__pyx_codeobj__369 +#define __pyx_codeobj__370 __pyx_mstate_global->__pyx_codeobj__370 +#define __pyx_codeobj__371 __pyx_mstate_global->__pyx_codeobj__371 +#define __pyx_codeobj__372 __pyx_mstate_global->__pyx_codeobj__372 +#define __pyx_codeobj__373 __pyx_mstate_global->__pyx_codeobj__373 +#define __pyx_codeobj__374 __pyx_mstate_global->__pyx_codeobj__374 +#define __pyx_codeobj__375 __pyx_mstate_global->__pyx_codeobj__375 +#define __pyx_codeobj__376 __pyx_mstate_global->__pyx_codeobj__376 +#define __pyx_codeobj__378 __pyx_mstate_global->__pyx_codeobj__378 +#define __pyx_codeobj__379 __pyx_mstate_global->__pyx_codeobj__379 +#define __pyx_codeobj__380 __pyx_mstate_global->__pyx_codeobj__380 +#define __pyx_codeobj__381 __pyx_mstate_global->__pyx_codeobj__381 +#define __pyx_codeobj__382 __pyx_mstate_global->__pyx_codeobj__382 +#define __pyx_codeobj__383 __pyx_mstate_global->__pyx_codeobj__383 +#define __pyx_codeobj__384 __pyx_mstate_global->__pyx_codeobj__384 +#define __pyx_codeobj__385 __pyx_mstate_global->__pyx_codeobj__385 +#define __pyx_codeobj__386 __pyx_mstate_global->__pyx_codeobj__386 +#define __pyx_codeobj__387 __pyx_mstate_global->__pyx_codeobj__387 +#define __pyx_codeobj__388 __pyx_mstate_global->__pyx_codeobj__388 +#define __pyx_codeobj__389 __pyx_mstate_global->__pyx_codeobj__389 +#define __pyx_codeobj__390 __pyx_mstate_global->__pyx_codeobj__390 +#define __pyx_codeobj__391 __pyx_mstate_global->__pyx_codeobj__391 +#define __pyx_codeobj__392 __pyx_mstate_global->__pyx_codeobj__392 +#define __pyx_codeobj__393 __pyx_mstate_global->__pyx_codeobj__393 +#define __pyx_codeobj__395 __pyx_mstate_global->__pyx_codeobj__395 +#define __pyx_codeobj__396 __pyx_mstate_global->__pyx_codeobj__396 +#define __pyx_codeobj__397 __pyx_mstate_global->__pyx_codeobj__397 +#define __pyx_codeobj__399 __pyx_mstate_global->__pyx_codeobj__399 +#define __pyx_codeobj__401 __pyx_mstate_global->__pyx_codeobj__401 +#define __pyx_codeobj__403 __pyx_mstate_global->__pyx_codeobj__403 +#define __pyx_codeobj__404 __pyx_mstate_global->__pyx_codeobj__404 +#define __pyx_codeobj__405 __pyx_mstate_global->__pyx_codeobj__405 +#define __pyx_codeobj__406 __pyx_mstate_global->__pyx_codeobj__406 +#define __pyx_codeobj__407 __pyx_mstate_global->__pyx_codeobj__407 +#define __pyx_codeobj__408 __pyx_mstate_global->__pyx_codeobj__408 +#define __pyx_codeobj__409 __pyx_mstate_global->__pyx_codeobj__409 +#define __pyx_codeobj__410 __pyx_mstate_global->__pyx_codeobj__410 +#define __pyx_codeobj__411 __pyx_mstate_global->__pyx_codeobj__411 +#define __pyx_codeobj__413 __pyx_mstate_global->__pyx_codeobj__413 +#define __pyx_codeobj__414 __pyx_mstate_global->__pyx_codeobj__414 +#define __pyx_codeobj__415 __pyx_mstate_global->__pyx_codeobj__415 +#define __pyx_codeobj__416 __pyx_mstate_global->__pyx_codeobj__416 +#define __pyx_codeobj__417 __pyx_mstate_global->__pyx_codeobj__417 +#define __pyx_codeobj__419 __pyx_mstate_global->__pyx_codeobj__419 +#define __pyx_codeobj__420 __pyx_mstate_global->__pyx_codeobj__420 +#define __pyx_codeobj__421 __pyx_mstate_global->__pyx_codeobj__421 +#define __pyx_codeobj__422 __pyx_mstate_global->__pyx_codeobj__422 +#define __pyx_codeobj__423 __pyx_mstate_global->__pyx_codeobj__423 +#define __pyx_codeobj__424 __pyx_mstate_global->__pyx_codeobj__424 +#define __pyx_codeobj__425 __pyx_mstate_global->__pyx_codeobj__425 +#define __pyx_codeobj__426 __pyx_mstate_global->__pyx_codeobj__426 +#define __pyx_codeobj__427 __pyx_mstate_global->__pyx_codeobj__427 +#define __pyx_codeobj__428 __pyx_mstate_global->__pyx_codeobj__428 +#define __pyx_codeobj__429 __pyx_mstate_global->__pyx_codeobj__429 +#define __pyx_codeobj__430 __pyx_mstate_global->__pyx_codeobj__430 +#define __pyx_codeobj__431 __pyx_mstate_global->__pyx_codeobj__431 +#define __pyx_codeobj__432 __pyx_mstate_global->__pyx_codeobj__432 +#define __pyx_codeobj__433 __pyx_mstate_global->__pyx_codeobj__433 +#define __pyx_codeobj__434 __pyx_mstate_global->__pyx_codeobj__434 +#define __pyx_codeobj__435 __pyx_mstate_global->__pyx_codeobj__435 +#define __pyx_codeobj__437 __pyx_mstate_global->__pyx_codeobj__437 +#define __pyx_codeobj__438 __pyx_mstate_global->__pyx_codeobj__438 +#define __pyx_codeobj__439 __pyx_mstate_global->__pyx_codeobj__439 +#define __pyx_codeobj__443 __pyx_mstate_global->__pyx_codeobj__443 +#define __pyx_codeobj__444 __pyx_mstate_global->__pyx_codeobj__444 +#define __pyx_codeobj__445 __pyx_mstate_global->__pyx_codeobj__445 +#define __pyx_codeobj__446 __pyx_mstate_global->__pyx_codeobj__446 +#define __pyx_codeobj__447 __pyx_mstate_global->__pyx_codeobj__447 +#define __pyx_codeobj__448 __pyx_mstate_global->__pyx_codeobj__448 +#define __pyx_codeobj__449 __pyx_mstate_global->__pyx_codeobj__449 +#define __pyx_codeobj__450 __pyx_mstate_global->__pyx_codeobj__450 +#define __pyx_codeobj__451 __pyx_mstate_global->__pyx_codeobj__451 +#define __pyx_codeobj__452 __pyx_mstate_global->__pyx_codeobj__452 +#define __pyx_codeobj__453 __pyx_mstate_global->__pyx_codeobj__453 +#define __pyx_codeobj__454 __pyx_mstate_global->__pyx_codeobj__454 +#define __pyx_codeobj__455 __pyx_mstate_global->__pyx_codeobj__455 +#define __pyx_codeobj__456 __pyx_mstate_global->__pyx_codeobj__456 +#define __pyx_codeobj__457 __pyx_mstate_global->__pyx_codeobj__457 +#define __pyx_codeobj__458 __pyx_mstate_global->__pyx_codeobj__458 +#define __pyx_codeobj__459 __pyx_mstate_global->__pyx_codeobj__459 +#define __pyx_codeobj__460 __pyx_mstate_global->__pyx_codeobj__460 +#define __pyx_codeobj__461 __pyx_mstate_global->__pyx_codeobj__461 +#define __pyx_codeobj__462 __pyx_mstate_global->__pyx_codeobj__462 +#define __pyx_codeobj__463 __pyx_mstate_global->__pyx_codeobj__463 +#define __pyx_codeobj__464 __pyx_mstate_global->__pyx_codeobj__464 +#define __pyx_codeobj__465 __pyx_mstate_global->__pyx_codeobj__465 +#define __pyx_codeobj__466 __pyx_mstate_global->__pyx_codeobj__466 +#define __pyx_codeobj__467 __pyx_mstate_global->__pyx_codeobj__467 +#define __pyx_codeobj__468 __pyx_mstate_global->__pyx_codeobj__468 +#define __pyx_codeobj__469 __pyx_mstate_global->__pyx_codeobj__469 +#define __pyx_codeobj__470 __pyx_mstate_global->__pyx_codeobj__470 +#define __pyx_codeobj__472 __pyx_mstate_global->__pyx_codeobj__472 +#define __pyx_codeobj__473 __pyx_mstate_global->__pyx_codeobj__473 +#define __pyx_codeobj__474 __pyx_mstate_global->__pyx_codeobj__474 +#define __pyx_codeobj__476 __pyx_mstate_global->__pyx_codeobj__476 +#define __pyx_codeobj__477 __pyx_mstate_global->__pyx_codeobj__477 +#define __pyx_codeobj__478 __pyx_mstate_global->__pyx_codeobj__478 +#define __pyx_codeobj__480 __pyx_mstate_global->__pyx_codeobj__480 +#define __pyx_codeobj__482 __pyx_mstate_global->__pyx_codeobj__482 +#define __pyx_codeobj__484 __pyx_mstate_global->__pyx_codeobj__484 +#define __pyx_codeobj__485 __pyx_mstate_global->__pyx_codeobj__485 +#define __pyx_codeobj__486 __pyx_mstate_global->__pyx_codeobj__486 +#define __pyx_codeobj__487 __pyx_mstate_global->__pyx_codeobj__487 +#define __pyx_codeobj__489 __pyx_mstate_global->__pyx_codeobj__489 +#define __pyx_codeobj__490 __pyx_mstate_global->__pyx_codeobj__490 +#define __pyx_codeobj__491 __pyx_mstate_global->__pyx_codeobj__491 +#define __pyx_codeobj__492 __pyx_mstate_global->__pyx_codeobj__492 +#define __pyx_codeobj__493 __pyx_mstate_global->__pyx_codeobj__493 +#define __pyx_codeobj__494 __pyx_mstate_global->__pyx_codeobj__494 +#define __pyx_codeobj__495 __pyx_mstate_global->__pyx_codeobj__495 +#define __pyx_codeobj__496 __pyx_mstate_global->__pyx_codeobj__496 +#define __pyx_codeobj__497 __pyx_mstate_global->__pyx_codeobj__497 +#define __pyx_codeobj__498 __pyx_mstate_global->__pyx_codeobj__498 +#define __pyx_codeobj__499 __pyx_mstate_global->__pyx_codeobj__499 +#define __pyx_codeobj__500 __pyx_mstate_global->__pyx_codeobj__500 +#define __pyx_codeobj__501 __pyx_mstate_global->__pyx_codeobj__501 +#define __pyx_codeobj__502 __pyx_mstate_global->__pyx_codeobj__502 +#define __pyx_codeobj__503 __pyx_mstate_global->__pyx_codeobj__503 +#define __pyx_codeobj__504 __pyx_mstate_global->__pyx_codeobj__504 +#define __pyx_codeobj__505 __pyx_mstate_global->__pyx_codeobj__505 +#define __pyx_codeobj__506 __pyx_mstate_global->__pyx_codeobj__506 +#define __pyx_codeobj__507 __pyx_mstate_global->__pyx_codeobj__507 +#define __pyx_codeobj__508 __pyx_mstate_global->__pyx_codeobj__508 +#define __pyx_codeobj__510 __pyx_mstate_global->__pyx_codeobj__510 +#define __pyx_codeobj__511 __pyx_mstate_global->__pyx_codeobj__511 +#define __pyx_codeobj__512 __pyx_mstate_global->__pyx_codeobj__512 +#define __pyx_codeobj__514 __pyx_mstate_global->__pyx_codeobj__514 +#define __pyx_codeobj__516 __pyx_mstate_global->__pyx_codeobj__516 +#define __pyx_codeobj__517 __pyx_mstate_global->__pyx_codeobj__517 +#define __pyx_codeobj__518 __pyx_mstate_global->__pyx_codeobj__518 +#define __pyx_codeobj__519 __pyx_mstate_global->__pyx_codeobj__519 +#define __pyx_codeobj__520 __pyx_mstate_global->__pyx_codeobj__520 +#define __pyx_codeobj__522 __pyx_mstate_global->__pyx_codeobj__522 +#define __pyx_codeobj__523 __pyx_mstate_global->__pyx_codeobj__523 +#define __pyx_codeobj__524 __pyx_mstate_global->__pyx_codeobj__524 +#define __pyx_codeobj__525 __pyx_mstate_global->__pyx_codeobj__525 +#define __pyx_codeobj__526 __pyx_mstate_global->__pyx_codeobj__526 +#define __pyx_codeobj__527 __pyx_mstate_global->__pyx_codeobj__527 +#define __pyx_codeobj__529 __pyx_mstate_global->__pyx_codeobj__529 +#define __pyx_codeobj__531 __pyx_mstate_global->__pyx_codeobj__531 +#define __pyx_codeobj__532 __pyx_mstate_global->__pyx_codeobj__532 +#define __pyx_codeobj__533 __pyx_mstate_global->__pyx_codeobj__533 +#define __pyx_codeobj__534 __pyx_mstate_global->__pyx_codeobj__534 +#define __pyx_codeobj__535 __pyx_mstate_global->__pyx_codeobj__535 +#define __pyx_codeobj__536 __pyx_mstate_global->__pyx_codeobj__536 +#define __pyx_codeobj__537 __pyx_mstate_global->__pyx_codeobj__537 +#define __pyx_codeobj__538 __pyx_mstate_global->__pyx_codeobj__538 +#define __pyx_codeobj__539 __pyx_mstate_global->__pyx_codeobj__539 +#define __pyx_codeobj__540 __pyx_mstate_global->__pyx_codeobj__540 +#define __pyx_codeobj__542 __pyx_mstate_global->__pyx_codeobj__542 +#define __pyx_codeobj__543 __pyx_mstate_global->__pyx_codeobj__543 +#define __pyx_codeobj__544 __pyx_mstate_global->__pyx_codeobj__544 +#define __pyx_codeobj__545 __pyx_mstate_global->__pyx_codeobj__545 +#define __pyx_codeobj__546 __pyx_mstate_global->__pyx_codeobj__546 +#define __pyx_codeobj__547 __pyx_mstate_global->__pyx_codeobj__547 +#define __pyx_codeobj__548 __pyx_mstate_global->__pyx_codeobj__548 +#define __pyx_codeobj__549 __pyx_mstate_global->__pyx_codeobj__549 +#define __pyx_codeobj__550 __pyx_mstate_global->__pyx_codeobj__550 +#define __pyx_codeobj__552 __pyx_mstate_global->__pyx_codeobj__552 +#define __pyx_codeobj__553 __pyx_mstate_global->__pyx_codeobj__553 +#define __pyx_codeobj__554 __pyx_mstate_global->__pyx_codeobj__554 +#define __pyx_codeobj__555 __pyx_mstate_global->__pyx_codeobj__555 +#define __pyx_codeobj__557 __pyx_mstate_global->__pyx_codeobj__557 +#define __pyx_codeobj__559 __pyx_mstate_global->__pyx_codeobj__559 +#define __pyx_codeobj__561 __pyx_mstate_global->__pyx_codeobj__561 +#define __pyx_codeobj__563 __pyx_mstate_global->__pyx_codeobj__563 +#define __pyx_codeobj__564 __pyx_mstate_global->__pyx_codeobj__564 +#define __pyx_codeobj__565 __pyx_mstate_global->__pyx_codeobj__565 +#define __pyx_codeobj__566 __pyx_mstate_global->__pyx_codeobj__566 +#define __pyx_codeobj__568 __pyx_mstate_global->__pyx_codeobj__568 +#define __pyx_codeobj__569 __pyx_mstate_global->__pyx_codeobj__569 +#define __pyx_codeobj__570 __pyx_mstate_global->__pyx_codeobj__570 +#define __pyx_codeobj__571 __pyx_mstate_global->__pyx_codeobj__571 +#define __pyx_codeobj__573 __pyx_mstate_global->__pyx_codeobj__573 +#define __pyx_codeobj__574 __pyx_mstate_global->__pyx_codeobj__574 +#define __pyx_codeobj__575 __pyx_mstate_global->__pyx_codeobj__575 +#define __pyx_codeobj__576 __pyx_mstate_global->__pyx_codeobj__576 +#define __pyx_codeobj__577 __pyx_mstate_global->__pyx_codeobj__577 +#define __pyx_codeobj__578 __pyx_mstate_global->__pyx_codeobj__578 +#define __pyx_codeobj__579 __pyx_mstate_global->__pyx_codeobj__579 +#define __pyx_codeobj__580 __pyx_mstate_global->__pyx_codeobj__580 +#define __pyx_codeobj__581 __pyx_mstate_global->__pyx_codeobj__581 +#define __pyx_codeobj__582 __pyx_mstate_global->__pyx_codeobj__582 +#define __pyx_codeobj__583 __pyx_mstate_global->__pyx_codeobj__583 +#define __pyx_codeobj__584 __pyx_mstate_global->__pyx_codeobj__584 +#define __pyx_codeobj__585 __pyx_mstate_global->__pyx_codeobj__585 +#define __pyx_codeobj__586 __pyx_mstate_global->__pyx_codeobj__586 +#define __pyx_codeobj__587 __pyx_mstate_global->__pyx_codeobj__587 +#define __pyx_codeobj__588 __pyx_mstate_global->__pyx_codeobj__588 +#define __pyx_codeobj__589 __pyx_mstate_global->__pyx_codeobj__589 +#define __pyx_codeobj__590 __pyx_mstate_global->__pyx_codeobj__590 +#define __pyx_codeobj__591 __pyx_mstate_global->__pyx_codeobj__591 +#define __pyx_codeobj__592 __pyx_mstate_global->__pyx_codeobj__592 +#define __pyx_codeobj__593 __pyx_mstate_global->__pyx_codeobj__593 +#define __pyx_codeobj__594 __pyx_mstate_global->__pyx_codeobj__594 +#define __pyx_codeobj__595 __pyx_mstate_global->__pyx_codeobj__595 +#define __pyx_codeobj__597 __pyx_mstate_global->__pyx_codeobj__597 +#define __pyx_codeobj__598 __pyx_mstate_global->__pyx_codeobj__598 +#define __pyx_codeobj__599 __pyx_mstate_global->__pyx_codeobj__599 +#define __pyx_codeobj__600 __pyx_mstate_global->__pyx_codeobj__600 +#define __pyx_codeobj__601 __pyx_mstate_global->__pyx_codeobj__601 +#define __pyx_codeobj__603 __pyx_mstate_global->__pyx_codeobj__603 +#define __pyx_codeobj__605 __pyx_mstate_global->__pyx_codeobj__605 +#define __pyx_codeobj__606 __pyx_mstate_global->__pyx_codeobj__606 +#define __pyx_codeobj__608 __pyx_mstate_global->__pyx_codeobj__608 +#define __pyx_codeobj__610 __pyx_mstate_global->__pyx_codeobj__610 +#define __pyx_codeobj__612 __pyx_mstate_global->__pyx_codeobj__612 +#define __pyx_codeobj__613 __pyx_mstate_global->__pyx_codeobj__613 +#define __pyx_codeobj__615 __pyx_mstate_global->__pyx_codeobj__615 +#define __pyx_codeobj__616 __pyx_mstate_global->__pyx_codeobj__616 +#define __pyx_codeobj__617 __pyx_mstate_global->__pyx_codeobj__617 +#define __pyx_codeobj__618 __pyx_mstate_global->__pyx_codeobj__618 +#define __pyx_codeobj__619 __pyx_mstate_global->__pyx_codeobj__619 +#define __pyx_codeobj__620 __pyx_mstate_global->__pyx_codeobj__620 +#define __pyx_codeobj__621 __pyx_mstate_global->__pyx_codeobj__621 +#define __pyx_codeobj__622 __pyx_mstate_global->__pyx_codeobj__622 +#define __pyx_codeobj__623 __pyx_mstate_global->__pyx_codeobj__623 +#define __pyx_codeobj__624 __pyx_mstate_global->__pyx_codeobj__624 +#define __pyx_codeobj__625 __pyx_mstate_global->__pyx_codeobj__625 +#define __pyx_codeobj__626 __pyx_mstate_global->__pyx_codeobj__626 +#define __pyx_codeobj__627 __pyx_mstate_global->__pyx_codeobj__627 +#define __pyx_codeobj__628 __pyx_mstate_global->__pyx_codeobj__628 +#define __pyx_codeobj__629 __pyx_mstate_global->__pyx_codeobj__629 +#define __pyx_codeobj__630 __pyx_mstate_global->__pyx_codeobj__630 +#define __pyx_codeobj__631 __pyx_mstate_global->__pyx_codeobj__631 +#define __pyx_codeobj__632 __pyx_mstate_global->__pyx_codeobj__632 +#define __pyx_codeobj__633 __pyx_mstate_global->__pyx_codeobj__633 +#define __pyx_codeobj__634 __pyx_mstate_global->__pyx_codeobj__634 +#define __pyx_codeobj__635 __pyx_mstate_global->__pyx_codeobj__635 +#define __pyx_codeobj__637 __pyx_mstate_global->__pyx_codeobj__637 +#define __pyx_codeobj__638 __pyx_mstate_global->__pyx_codeobj__638 +#define __pyx_codeobj__639 __pyx_mstate_global->__pyx_codeobj__639 +#define __pyx_codeobj__640 __pyx_mstate_global->__pyx_codeobj__640 +#define __pyx_codeobj__641 __pyx_mstate_global->__pyx_codeobj__641 +#define __pyx_codeobj__642 __pyx_mstate_global->__pyx_codeobj__642 +#define __pyx_codeobj__643 __pyx_mstate_global->__pyx_codeobj__643 +#define __pyx_codeobj__645 __pyx_mstate_global->__pyx_codeobj__645 +#define __pyx_codeobj__646 __pyx_mstate_global->__pyx_codeobj__646 +#define __pyx_codeobj__647 __pyx_mstate_global->__pyx_codeobj__647 +#define __pyx_codeobj__648 __pyx_mstate_global->__pyx_codeobj__648 +#define __pyx_codeobj__649 __pyx_mstate_global->__pyx_codeobj__649 +#define __pyx_codeobj__650 __pyx_mstate_global->__pyx_codeobj__650 +#define __pyx_codeobj__652 __pyx_mstate_global->__pyx_codeobj__652 +#define __pyx_codeobj__655 __pyx_mstate_global->__pyx_codeobj__655 +#define __pyx_codeobj__657 __pyx_mstate_global->__pyx_codeobj__657 +#define __pyx_codeobj__658 __pyx_mstate_global->__pyx_codeobj__658 +#define __pyx_codeobj__659 __pyx_mstate_global->__pyx_codeobj__659 +#define __pyx_codeobj__661 __pyx_mstate_global->__pyx_codeobj__661 +#define __pyx_codeobj__662 __pyx_mstate_global->__pyx_codeobj__662 +#define __pyx_codeobj__664 __pyx_mstate_global->__pyx_codeobj__664 +#define __pyx_codeobj__667 __pyx_mstate_global->__pyx_codeobj__667 +#define __pyx_codeobj__669 __pyx_mstate_global->__pyx_codeobj__669 +#define __pyx_codeobj__671 __pyx_mstate_global->__pyx_codeobj__671 +#define __pyx_codeobj__672 __pyx_mstate_global->__pyx_codeobj__672 +#define __pyx_codeobj__673 __pyx_mstate_global->__pyx_codeobj__673 +#define __pyx_codeobj__675 __pyx_mstate_global->__pyx_codeobj__675 +#define __pyx_codeobj__677 __pyx_mstate_global->__pyx_codeobj__677 +#define __pyx_codeobj__678 __pyx_mstate_global->__pyx_codeobj__678 +#define __pyx_codeobj__679 __pyx_mstate_global->__pyx_codeobj__679 +#define __pyx_codeobj__681 __pyx_mstate_global->__pyx_codeobj__681 +#define __pyx_codeobj__683 __pyx_mstate_global->__pyx_codeobj__683 +#define __pyx_codeobj__686 __pyx_mstate_global->__pyx_codeobj__686 +#define __pyx_codeobj__689 __pyx_mstate_global->__pyx_codeobj__689 +#define __pyx_codeobj__691 __pyx_mstate_global->__pyx_codeobj__691 +#define __pyx_codeobj__693 __pyx_mstate_global->__pyx_codeobj__693 +#define __pyx_codeobj__695 __pyx_mstate_global->__pyx_codeobj__695 +#define __pyx_codeobj__697 __pyx_mstate_global->__pyx_codeobj__697 +#define __pyx_codeobj__699 __pyx_mstate_global->__pyx_codeobj__699 +#define __pyx_codeobj__700 __pyx_mstate_global->__pyx_codeobj__700 +#define __pyx_codeobj__701 __pyx_mstate_global->__pyx_codeobj__701 +#define __pyx_codeobj__703 __pyx_mstate_global->__pyx_codeobj__703 +#define __pyx_codeobj__705 __pyx_mstate_global->__pyx_codeobj__705 +#define __pyx_codeobj__706 __pyx_mstate_global->__pyx_codeobj__706 +#define __pyx_codeobj__707 __pyx_mstate_global->__pyx_codeobj__707 +#define __pyx_codeobj__709 __pyx_mstate_global->__pyx_codeobj__709 +#define __pyx_codeobj__711 __pyx_mstate_global->__pyx_codeobj__711 +#define __pyx_codeobj__713 __pyx_mstate_global->__pyx_codeobj__713 +#define __pyx_codeobj__715 __pyx_mstate_global->__pyx_codeobj__715 +#define __pyx_codeobj__717 __pyx_mstate_global->__pyx_codeobj__717 +#define __pyx_codeobj__718 __pyx_mstate_global->__pyx_codeobj__718 +#define __pyx_codeobj__719 __pyx_mstate_global->__pyx_codeobj__719 +#define __pyx_codeobj__721 __pyx_mstate_global->__pyx_codeobj__721 +#define __pyx_codeobj__723 __pyx_mstate_global->__pyx_codeobj__723 +#define __pyx_codeobj__724 __pyx_mstate_global->__pyx_codeobj__724 +#define __pyx_codeobj__725 __pyx_mstate_global->__pyx_codeobj__725 +#define __pyx_codeobj__726 __pyx_mstate_global->__pyx_codeobj__726 +#define __pyx_codeobj__727 __pyx_mstate_global->__pyx_codeobj__727 +#define __pyx_codeobj__728 __pyx_mstate_global->__pyx_codeobj__728 +#define __pyx_codeobj__729 __pyx_mstate_global->__pyx_codeobj__729 +#define __pyx_codeobj__731 __pyx_mstate_global->__pyx_codeobj__731 +#define __pyx_codeobj__732 __pyx_mstate_global->__pyx_codeobj__732 +#define __pyx_codeobj__733 __pyx_mstate_global->__pyx_codeobj__733 +#define __pyx_codeobj__735 __pyx_mstate_global->__pyx_codeobj__735 +#define __pyx_codeobj__736 __pyx_mstate_global->__pyx_codeobj__736 +#define __pyx_codeobj__738 __pyx_mstate_global->__pyx_codeobj__738 +#define __pyx_codeobj__740 __pyx_mstate_global->__pyx_codeobj__740 +#define __pyx_codeobj__741 __pyx_mstate_global->__pyx_codeobj__741 +#define __pyx_codeobj__742 __pyx_mstate_global->__pyx_codeobj__742 +#define __pyx_codeobj__744 __pyx_mstate_global->__pyx_codeobj__744 +#define __pyx_codeobj__746 __pyx_mstate_global->__pyx_codeobj__746 +#define __pyx_codeobj__748 __pyx_mstate_global->__pyx_codeobj__748 +#define __pyx_codeobj__749 __pyx_mstate_global->__pyx_codeobj__749 +#define __pyx_codeobj__751 __pyx_mstate_global->__pyx_codeobj__751 +#define __pyx_codeobj__754 __pyx_mstate_global->__pyx_codeobj__754 +#define __pyx_codeobj__755 __pyx_mstate_global->__pyx_codeobj__755 +#define __pyx_codeobj__756 __pyx_mstate_global->__pyx_codeobj__756 +#define __pyx_codeobj__757 __pyx_mstate_global->__pyx_codeobj__757 +#define __pyx_codeobj__758 __pyx_mstate_global->__pyx_codeobj__758 +#define __pyx_codeobj__759 __pyx_mstate_global->__pyx_codeobj__759 +#define __pyx_codeobj__761 __pyx_mstate_global->__pyx_codeobj__761 +#define __pyx_codeobj__762 __pyx_mstate_global->__pyx_codeobj__762 +#define __pyx_codeobj__763 __pyx_mstate_global->__pyx_codeobj__763 +#define __pyx_codeobj__764 __pyx_mstate_global->__pyx_codeobj__764 +#define __pyx_codeobj__766 __pyx_mstate_global->__pyx_codeobj__766 +#define __pyx_codeobj__768 __pyx_mstate_global->__pyx_codeobj__768 +#define __pyx_codeobj__769 __pyx_mstate_global->__pyx_codeobj__769 +#define __pyx_codeobj__771 __pyx_mstate_global->__pyx_codeobj__771 +#define __pyx_codeobj__773 __pyx_mstate_global->__pyx_codeobj__773 +#define __pyx_codeobj__774 __pyx_mstate_global->__pyx_codeobj__774 +#define __pyx_codeobj__776 __pyx_mstate_global->__pyx_codeobj__776 +#define __pyx_codeobj__777 __pyx_mstate_global->__pyx_codeobj__777 +#define __pyx_codeobj__778 __pyx_mstate_global->__pyx_codeobj__778 +#define __pyx_codeobj__779 __pyx_mstate_global->__pyx_codeobj__779 +#define __pyx_codeobj__781 __pyx_mstate_global->__pyx_codeobj__781 +#define __pyx_codeobj__784 __pyx_mstate_global->__pyx_codeobj__784 +#define __pyx_codeobj__786 __pyx_mstate_global->__pyx_codeobj__786 +#define __pyx_codeobj__788 __pyx_mstate_global->__pyx_codeobj__788 +#define __pyx_codeobj__790 __pyx_mstate_global->__pyx_codeobj__790 +#define __pyx_codeobj__792 __pyx_mstate_global->__pyx_codeobj__792 +#define __pyx_codeobj__795 __pyx_mstate_global->__pyx_codeobj__795 +#define __pyx_codeobj__797 __pyx_mstate_global->__pyx_codeobj__797 +#define __pyx_codeobj__799 __pyx_mstate_global->__pyx_codeobj__799 +#define __pyx_codeobj__802 __pyx_mstate_global->__pyx_codeobj__802 +#define __pyx_codeobj__804 __pyx_mstate_global->__pyx_codeobj__804 +#define __pyx_codeobj__806 __pyx_mstate_global->__pyx_codeobj__806 +#define __pyx_codeobj__807 __pyx_mstate_global->__pyx_codeobj__807 +#define __pyx_codeobj__809 __pyx_mstate_global->__pyx_codeobj__809 +#define __pyx_codeobj__811 __pyx_mstate_global->__pyx_codeobj__811 +#define __pyx_codeobj__813 __pyx_mstate_global->__pyx_codeobj__813 +#define __pyx_codeobj__815 __pyx_mstate_global->__pyx_codeobj__815 +#define __pyx_codeobj__817 __pyx_mstate_global->__pyx_codeobj__817 +#define __pyx_codeobj__819 __pyx_mstate_global->__pyx_codeobj__819 +#define __pyx_codeobj__822 __pyx_mstate_global->__pyx_codeobj__822 +#define __pyx_codeobj__824 __pyx_mstate_global->__pyx_codeobj__824 +#define __pyx_codeobj__827 __pyx_mstate_global->__pyx_codeobj__827 +#define __pyx_codeobj__830 __pyx_mstate_global->__pyx_codeobj__830 +#define __pyx_codeobj__833 __pyx_mstate_global->__pyx_codeobj__833 +#define __pyx_codeobj__836 __pyx_mstate_global->__pyx_codeobj__836 +#define __pyx_codeobj__838 __pyx_mstate_global->__pyx_codeobj__838 +#define __pyx_codeobj__840 __pyx_mstate_global->__pyx_codeobj__840 +#define __pyx_codeobj__841 __pyx_mstate_global->__pyx_codeobj__841 +#define __pyx_codeobj__842 __pyx_mstate_global->__pyx_codeobj__842 +#define __pyx_codeobj__843 __pyx_mstate_global->__pyx_codeobj__843 +#define __pyx_codeobj__845 __pyx_mstate_global->__pyx_codeobj__845 +#define __pyx_codeobj__847 __pyx_mstate_global->__pyx_codeobj__847 +#define __pyx_codeobj__849 __pyx_mstate_global->__pyx_codeobj__849 +#define __pyx_codeobj__851 __pyx_mstate_global->__pyx_codeobj__851 +#define __pyx_codeobj__853 __pyx_mstate_global->__pyx_codeobj__853 +#define __pyx_codeobj__855 __pyx_mstate_global->__pyx_codeobj__855 +#define __pyx_codeobj__857 __pyx_mstate_global->__pyx_codeobj__857 +#define __pyx_codeobj__858 __pyx_mstate_global->__pyx_codeobj__858 +#define __pyx_codeobj__860 __pyx_mstate_global->__pyx_codeobj__860 +#define __pyx_codeobj__861 __pyx_mstate_global->__pyx_codeobj__861 +#define __pyx_codeobj__862 __pyx_mstate_global->__pyx_codeobj__862 +#define __pyx_codeobj__864 __pyx_mstate_global->__pyx_codeobj__864 +#define __pyx_codeobj__866 __pyx_mstate_global->__pyx_codeobj__866 +#define __pyx_codeobj__868 __pyx_mstate_global->__pyx_codeobj__868 +#define __pyx_codeobj__869 __pyx_mstate_global->__pyx_codeobj__869 +#define __pyx_codeobj__870 __pyx_mstate_global->__pyx_codeobj__870 +#define __pyx_codeobj__872 __pyx_mstate_global->__pyx_codeobj__872 +#define __pyx_codeobj__874 __pyx_mstate_global->__pyx_codeobj__874 +#define __pyx_codeobj__876 __pyx_mstate_global->__pyx_codeobj__876 +#define __pyx_codeobj__878 __pyx_mstate_global->__pyx_codeobj__878 +#define __pyx_codeobj__880 __pyx_mstate_global->__pyx_codeobj__880 +#define __pyx_codeobj__882 __pyx_mstate_global->__pyx_codeobj__882 +#define __pyx_codeobj__884 __pyx_mstate_global->__pyx_codeobj__884 +#define __pyx_codeobj__886 __pyx_mstate_global->__pyx_codeobj__886 +#define __pyx_codeobj__888 __pyx_mstate_global->__pyx_codeobj__888 +#define __pyx_codeobj__889 __pyx_mstate_global->__pyx_codeobj__889 +#define __pyx_codeobj__890 __pyx_mstate_global->__pyx_codeobj__890 +#define __pyx_codeobj__891 __pyx_mstate_global->__pyx_codeobj__891 +#define __pyx_codeobj__893 __pyx_mstate_global->__pyx_codeobj__893 +#define __pyx_codeobj__895 __pyx_mstate_global->__pyx_codeobj__895 +#define __pyx_codeobj__897 __pyx_mstate_global->__pyx_codeobj__897 +#define __pyx_codeobj__898 __pyx_mstate_global->__pyx_codeobj__898 +#define __pyx_codeobj__899 __pyx_mstate_global->__pyx_codeobj__899 +#define __pyx_codeobj__901 __pyx_mstate_global->__pyx_codeobj__901 +#define __pyx_codeobj__903 __pyx_mstate_global->__pyx_codeobj__903 +#define __pyx_codeobj__904 __pyx_mstate_global->__pyx_codeobj__904 +#define __pyx_codeobj__905 __pyx_mstate_global->__pyx_codeobj__905 +#define __pyx_codeobj__906 __pyx_mstate_global->__pyx_codeobj__906 +#define __pyx_codeobj__908 __pyx_mstate_global->__pyx_codeobj__908 +#define __pyx_codeobj__910 __pyx_mstate_global->__pyx_codeobj__910 +#define __pyx_codeobj__912 __pyx_mstate_global->__pyx_codeobj__912 +#define __pyx_codeobj__914 __pyx_mstate_global->__pyx_codeobj__914 +#define __pyx_codeobj__916 __pyx_mstate_global->__pyx_codeobj__916 +#define __pyx_codeobj__918 __pyx_mstate_global->__pyx_codeobj__918 +#define __pyx_codeobj__920 __pyx_mstate_global->__pyx_codeobj__920 +#define __pyx_codeobj__922 __pyx_mstate_global->__pyx_codeobj__922 +#define __pyx_codeobj__924 __pyx_mstate_global->__pyx_codeobj__924 +#define __pyx_codeobj__926 __pyx_mstate_global->__pyx_codeobj__926 +#define __pyx_codeobj__928 __pyx_mstate_global->__pyx_codeobj__928 +#define __pyx_codeobj__931 __pyx_mstate_global->__pyx_codeobj__931 +#define __pyx_codeobj__933 __pyx_mstate_global->__pyx_codeobj__933 +#define __pyx_codeobj__935 __pyx_mstate_global->__pyx_codeobj__935 +#define __pyx_codeobj__937 __pyx_mstate_global->__pyx_codeobj__937 +#define __pyx_codeobj__939 __pyx_mstate_global->__pyx_codeobj__939 +#define __pyx_codeobj__942 __pyx_mstate_global->__pyx_codeobj__942 +#define __pyx_codeobj__944 __pyx_mstate_global->__pyx_codeobj__944 +#define __pyx_codeobj__947 __pyx_mstate_global->__pyx_codeobj__947 +#define __pyx_codeobj__949 __pyx_mstate_global->__pyx_codeobj__949 +#define __pyx_codeobj__952 __pyx_mstate_global->__pyx_codeobj__952 +#define __pyx_codeobj__954 __pyx_mstate_global->__pyx_codeobj__954 +#define __pyx_codeobj__956 __pyx_mstate_global->__pyx_codeobj__956 +#define __pyx_codeobj__958 __pyx_mstate_global->__pyx_codeobj__958 +#define __pyx_codeobj__961 __pyx_mstate_global->__pyx_codeobj__961 +#define __pyx_codeobj__963 __pyx_mstate_global->__pyx_codeobj__963 +#define __pyx_codeobj__965 __pyx_mstate_global->__pyx_codeobj__965 +#define __pyx_codeobj__967 __pyx_mstate_global->__pyx_codeobj__967 +#define __pyx_codeobj__970 __pyx_mstate_global->__pyx_codeobj__970 +#define __pyx_codeobj__972 __pyx_mstate_global->__pyx_codeobj__972 +#define __pyx_codeobj__974 __pyx_mstate_global->__pyx_codeobj__974 +#define __pyx_codeobj__976 __pyx_mstate_global->__pyx_codeobj__976 +#define __pyx_codeobj__978 __pyx_mstate_global->__pyx_codeobj__978 +#define __pyx_codeobj__980 __pyx_mstate_global->__pyx_codeobj__980 +#define __pyx_codeobj__982 __pyx_mstate_global->__pyx_codeobj__982 +#define __pyx_codeobj__984 __pyx_mstate_global->__pyx_codeobj__984 +#define __pyx_codeobj__985 __pyx_mstate_global->__pyx_codeobj__985 +#define __pyx_codeobj__986 __pyx_mstate_global->__pyx_codeobj__986 +#define __pyx_codeobj__988 __pyx_mstate_global->__pyx_codeobj__988 +#define __pyx_codeobj__990 __pyx_mstate_global->__pyx_codeobj__990 +#define __pyx_codeobj__991 __pyx_mstate_global->__pyx_codeobj__991 +#define __pyx_codeobj__992 __pyx_mstate_global->__pyx_codeobj__992 +#define __pyx_codeobj__993 __pyx_mstate_global->__pyx_codeobj__993 +#define __pyx_codeobj__995 __pyx_mstate_global->__pyx_codeobj__995 +#define __pyx_codeobj__997 __pyx_mstate_global->__pyx_codeobj__997 +#define __pyx_codeobj__998 __pyx_mstate_global->__pyx_codeobj__998 +#define __pyx_codeobj__1000 __pyx_mstate_global->__pyx_codeobj__1000 +#define __pyx_codeobj__1002 __pyx_mstate_global->__pyx_codeobj__1002 +#define __pyx_codeobj__1003 __pyx_mstate_global->__pyx_codeobj__1003 +#define __pyx_codeobj__1004 __pyx_mstate_global->__pyx_codeobj__1004 +#define __pyx_codeobj__1005 __pyx_mstate_global->__pyx_codeobj__1005 +#define __pyx_codeobj__1007 __pyx_mstate_global->__pyx_codeobj__1007 +#define __pyx_codeobj__1008 __pyx_mstate_global->__pyx_codeobj__1008 +#define __pyx_codeobj__1009 __pyx_mstate_global->__pyx_codeobj__1009 +#define __pyx_codeobj__1010 __pyx_mstate_global->__pyx_codeobj__1010 +#define __pyx_codeobj__1011 __pyx_mstate_global->__pyx_codeobj__1011 +#define __pyx_codeobj__1013 __pyx_mstate_global->__pyx_codeobj__1013 +#define __pyx_codeobj__1014 __pyx_mstate_global->__pyx_codeobj__1014 +#define __pyx_codeobj__1015 __pyx_mstate_global->__pyx_codeobj__1015 +#define __pyx_codeobj__1016 __pyx_mstate_global->__pyx_codeobj__1016 +#define __pyx_codeobj__1017 __pyx_mstate_global->__pyx_codeobj__1017 +#define __pyx_codeobj__1019 __pyx_mstate_global->__pyx_codeobj__1019 +#define __pyx_codeobj__1020 __pyx_mstate_global->__pyx_codeobj__1020 +#define __pyx_codeobj__1021 __pyx_mstate_global->__pyx_codeobj__1021 +#define __pyx_codeobj__1023 __pyx_mstate_global->__pyx_codeobj__1023 +#define __pyx_codeobj__1026 __pyx_mstate_global->__pyx_codeobj__1026 +#define __pyx_codeobj__1028 __pyx_mstate_global->__pyx_codeobj__1028 +#define __pyx_codeobj__1029 __pyx_mstate_global->__pyx_codeobj__1029 +#define __pyx_codeobj__1031 __pyx_mstate_global->__pyx_codeobj__1031 +#define __pyx_codeobj__1033 __pyx_mstate_global->__pyx_codeobj__1033 +#define __pyx_codeobj__1036 __pyx_mstate_global->__pyx_codeobj__1036 +#define __pyx_codeobj__1038 __pyx_mstate_global->__pyx_codeobj__1038 +#define __pyx_codeobj__1041 __pyx_mstate_global->__pyx_codeobj__1041 +#define __pyx_codeobj__1042 __pyx_mstate_global->__pyx_codeobj__1042 +#define __pyx_codeobj__1043 __pyx_mstate_global->__pyx_codeobj__1043 +#define __pyx_codeobj__1045 __pyx_mstate_global->__pyx_codeobj__1045 +#define __pyx_codeobj__1047 __pyx_mstate_global->__pyx_codeobj__1047 +#define __pyx_codeobj__1049 __pyx_mstate_global->__pyx_codeobj__1049 +#define __pyx_codeobj__1052 __pyx_mstate_global->__pyx_codeobj__1052 +#define __pyx_codeobj__1055 __pyx_mstate_global->__pyx_codeobj__1055 +#define __pyx_codeobj__1056 __pyx_mstate_global->__pyx_codeobj__1056 +#define __pyx_codeobj__1057 __pyx_mstate_global->__pyx_codeobj__1057 +#define __pyx_codeobj__1058 __pyx_mstate_global->__pyx_codeobj__1058 +#define __pyx_codeobj__1059 __pyx_mstate_global->__pyx_codeobj__1059 +#define __pyx_codeobj__1060 __pyx_mstate_global->__pyx_codeobj__1060 +#define __pyx_codeobj__1062 __pyx_mstate_global->__pyx_codeobj__1062 +#define __pyx_codeobj__1063 __pyx_mstate_global->__pyx_codeobj__1063 +#define __pyx_codeobj__1065 __pyx_mstate_global->__pyx_codeobj__1065 +#define __pyx_codeobj__1067 __pyx_mstate_global->__pyx_codeobj__1067 +#define __pyx_codeobj__1068 __pyx_mstate_global->__pyx_codeobj__1068 +#define __pyx_codeobj__1070 __pyx_mstate_global->__pyx_codeobj__1070 +#define __pyx_codeobj__1072 __pyx_mstate_global->__pyx_codeobj__1072 +#define __pyx_codeobj__1073 __pyx_mstate_global->__pyx_codeobj__1073 +#define __pyx_codeobj__1074 __pyx_mstate_global->__pyx_codeobj__1074 +#define __pyx_codeobj__1076 __pyx_mstate_global->__pyx_codeobj__1076 +#define __pyx_codeobj__1077 __pyx_mstate_global->__pyx_codeobj__1077 +#define __pyx_codeobj__1078 __pyx_mstate_global->__pyx_codeobj__1078 +#define __pyx_codeobj__1079 __pyx_mstate_global->__pyx_codeobj__1079 +#define __pyx_codeobj__1081 __pyx_mstate_global->__pyx_codeobj__1081 +#define __pyx_codeobj__1082 __pyx_mstate_global->__pyx_codeobj__1082 +#define __pyx_codeobj__1083 __pyx_mstate_global->__pyx_codeobj__1083 +#define __pyx_codeobj__1084 __pyx_mstate_global->__pyx_codeobj__1084 +#define __pyx_codeobj__1085 __pyx_mstate_global->__pyx_codeobj__1085 +#define __pyx_codeobj__1087 __pyx_mstate_global->__pyx_codeobj__1087 +#define __pyx_codeobj__1089 __pyx_mstate_global->__pyx_codeobj__1089 +#define __pyx_codeobj__1090 __pyx_mstate_global->__pyx_codeobj__1090 +#define __pyx_codeobj__1092 __pyx_mstate_global->__pyx_codeobj__1092 +#define __pyx_codeobj__1093 __pyx_mstate_global->__pyx_codeobj__1093 +#define __pyx_codeobj__1095 __pyx_mstate_global->__pyx_codeobj__1095 +#define __pyx_codeobj__1096 __pyx_mstate_global->__pyx_codeobj__1096 +#define __pyx_codeobj__1097 __pyx_mstate_global->__pyx_codeobj__1097 +#define __pyx_codeobj__1099 __pyx_mstate_global->__pyx_codeobj__1099 +#define __pyx_codeobj__1101 __pyx_mstate_global->__pyx_codeobj__1101 +#define __pyx_codeobj__1103 __pyx_mstate_global->__pyx_codeobj__1103 +#define __pyx_codeobj__1105 __pyx_mstate_global->__pyx_codeobj__1105 +#define __pyx_codeobj__1107 __pyx_mstate_global->__pyx_codeobj__1107 +#define __pyx_codeobj__1109 __pyx_mstate_global->__pyx_codeobj__1109 +#define __pyx_codeobj__1110 __pyx_mstate_global->__pyx_codeobj__1110 +#define __pyx_codeobj__1111 __pyx_mstate_global->__pyx_codeobj__1111 +#define __pyx_codeobj__1112 __pyx_mstate_global->__pyx_codeobj__1112 +#define __pyx_codeobj__1113 __pyx_mstate_global->__pyx_codeobj__1113 +#define __pyx_codeobj__1115 __pyx_mstate_global->__pyx_codeobj__1115 +#define __pyx_codeobj__1117 __pyx_mstate_global->__pyx_codeobj__1117 +#define __pyx_codeobj__1119 __pyx_mstate_global->__pyx_codeobj__1119 +#define __pyx_codeobj__1121 __pyx_mstate_global->__pyx_codeobj__1121 +#define __pyx_codeobj__1123 __pyx_mstate_global->__pyx_codeobj__1123 +#define __pyx_codeobj__1125 __pyx_mstate_global->__pyx_codeobj__1125 +#define __pyx_codeobj__1127 __pyx_mstate_global->__pyx_codeobj__1127 +#define __pyx_codeobj__1129 __pyx_mstate_global->__pyx_codeobj__1129 +#define __pyx_codeobj__1130 __pyx_mstate_global->__pyx_codeobj__1130 +#define __pyx_codeobj__1132 __pyx_mstate_global->__pyx_codeobj__1132 +#define __pyx_codeobj__1134 __pyx_mstate_global->__pyx_codeobj__1134 +#define __pyx_codeobj__1135 __pyx_mstate_global->__pyx_codeobj__1135 +#define __pyx_codeobj__1136 __pyx_mstate_global->__pyx_codeobj__1136 +#define __pyx_codeobj__1138 __pyx_mstate_global->__pyx_codeobj__1138 +#define __pyx_codeobj__1139 __pyx_mstate_global->__pyx_codeobj__1139 +#define __pyx_codeobj__1140 __pyx_mstate_global->__pyx_codeobj__1140 +#define __pyx_codeobj__1142 __pyx_mstate_global->__pyx_codeobj__1142 +#define __pyx_codeobj__1145 __pyx_mstate_global->__pyx_codeobj__1145 +#define __pyx_codeobj__1146 __pyx_mstate_global->__pyx_codeobj__1146 +#define __pyx_codeobj__1147 __pyx_mstate_global->__pyx_codeobj__1147 +#define __pyx_codeobj__1148 __pyx_mstate_global->__pyx_codeobj__1148 +#define __pyx_codeobj__1149 __pyx_mstate_global->__pyx_codeobj__1149 +#define __pyx_codeobj__1150 __pyx_mstate_global->__pyx_codeobj__1150 +#define __pyx_codeobj__1152 __pyx_mstate_global->__pyx_codeobj__1152 +#define __pyx_codeobj__1153 __pyx_mstate_global->__pyx_codeobj__1153 +#define __pyx_codeobj__1154 __pyx_mstate_global->__pyx_codeobj__1154 +#define __pyx_codeobj__1155 __pyx_mstate_global->__pyx_codeobj__1155 +#define __pyx_codeobj__1156 __pyx_mstate_global->__pyx_codeobj__1156 +#define __pyx_codeobj__1157 __pyx_mstate_global->__pyx_codeobj__1157 +#define __pyx_codeobj__1158 __pyx_mstate_global->__pyx_codeobj__1158 +#define __pyx_codeobj__1159 __pyx_mstate_global->__pyx_codeobj__1159 +#define __pyx_codeobj__1160 __pyx_mstate_global->__pyx_codeobj__1160 +#define __pyx_codeobj__1161 __pyx_mstate_global->__pyx_codeobj__1161 +#define __pyx_codeobj__1162 __pyx_mstate_global->__pyx_codeobj__1162 +#define __pyx_codeobj__1163 __pyx_mstate_global->__pyx_codeobj__1163 +#define __pyx_codeobj__1164 __pyx_mstate_global->__pyx_codeobj__1164 +#define __pyx_codeobj__1165 __pyx_mstate_global->__pyx_codeobj__1165 +#define __pyx_codeobj__1166 __pyx_mstate_global->__pyx_codeobj__1166 +#define __pyx_codeobj__1167 __pyx_mstate_global->__pyx_codeobj__1167 +#define __pyx_codeobj__1168 __pyx_mstate_global->__pyx_codeobj__1168 +#define __pyx_codeobj__1169 __pyx_mstate_global->__pyx_codeobj__1169 +#define __pyx_codeobj__1170 __pyx_mstate_global->__pyx_codeobj__1170 +#define __pyx_codeobj__1171 __pyx_mstate_global->__pyx_codeobj__1171 +#define __pyx_codeobj__1172 __pyx_mstate_global->__pyx_codeobj__1172 +#define __pyx_codeobj__1173 __pyx_mstate_global->__pyx_codeobj__1173 +#define __pyx_codeobj__1174 __pyx_mstate_global->__pyx_codeobj__1174 +#define __pyx_codeobj__1175 __pyx_mstate_global->__pyx_codeobj__1175 +#define __pyx_codeobj__1176 __pyx_mstate_global->__pyx_codeobj__1176 +#define __pyx_codeobj__1177 __pyx_mstate_global->__pyx_codeobj__1177 +#define __pyx_codeobj__1178 __pyx_mstate_global->__pyx_codeobj__1178 +#define __pyx_codeobj__1179 __pyx_mstate_global->__pyx_codeobj__1179 +#define __pyx_codeobj__1180 __pyx_mstate_global->__pyx_codeobj__1180 +#define __pyx_codeobj__1181 __pyx_mstate_global->__pyx_codeobj__1181 +#define __pyx_codeobj__1182 __pyx_mstate_global->__pyx_codeobj__1182 +#define __pyx_codeobj__1183 __pyx_mstate_global->__pyx_codeobj__1183 +#define __pyx_codeobj__1184 __pyx_mstate_global->__pyx_codeobj__1184 +#define __pyx_codeobj__1185 __pyx_mstate_global->__pyx_codeobj__1185 +#define __pyx_codeobj__1186 __pyx_mstate_global->__pyx_codeobj__1186 +#define __pyx_codeobj__1187 __pyx_mstate_global->__pyx_codeobj__1187 +/* #### Code section: module_code ### */ + +/* "src/pyscipopt/scip.pxi":47 + * + * if sys.version_info >= (3, 0): + * str_conversion = lambda x:bytes(x,'utf-8') # <<<<<<<<<<<<<< + * else: + * str_conversion = lambda x:x + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_76lambda7(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_76lambda7 = {"lambda7", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_76lambda7, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_9pyscipopt_4scip_76lambda7(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_x = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lambda7 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_x)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 47, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "lambda7") < 0)) __PYX_ERR(0, 47, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_x = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lambda7", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 47, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.lambda7", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_lambda_funcdef_9pyscipopt_4scip_lambda7(__pyx_self, __pyx_v_x); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_lambda_funcdef_9pyscipopt_4scip_lambda7(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lambda7", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_x); + __Pyx_GIVEREF(__pyx_v_x); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_x)) __PYX_ERR(0, 47, __pyx_L1_error); + __Pyx_INCREF(__pyx_kp_u_utf_8); + __Pyx_GIVEREF(__pyx_kp_u_utf_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_kp_u_utf_8)) __PYX_ERR(0, 47, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyBytes_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.lambda7", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":49 + * str_conversion = lambda x:bytes(x,'utf-8') + * else: + * str_conversion = lambda x:x # <<<<<<<<<<<<<< + * + * _SCIP_BOUNDTYPE_TO_STRING = {SCIP_BOUNDTYPE_UPPER: '<=', + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_77lambda8(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_77lambda8 = {"lambda8", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_77lambda8, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_9pyscipopt_4scip_77lambda8(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_x = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lambda8 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_x)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 49, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "lambda8") < 0)) __PYX_ERR(0, 49, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_x = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lambda8", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 49, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.lambda8", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_lambda_funcdef_9pyscipopt_4scip_lambda8(__pyx_self, __pyx_v_x); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_lambda_funcdef_9pyscipopt_4scip_lambda8(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_x) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lambda8", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cpython/complex.pxd":19 + * + * @property + * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.real + * + */ + +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4real_real(PyComplexObject *__pyx_v_self) { + double __pyx_r; + + /* "cpython/complex.pxd":20 + * @property + * cdef inline double real(self) noexcept: + * return self.cval.real # <<<<<<<<<<<<<< + * + * @property + */ + __pyx_r = __pyx_v_self->cval.real; + goto __pyx_L0; + + /* "cpython/complex.pxd":19 + * + * @property + * cdef inline double real(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.real + * + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cpython/complex.pxd":23 + * + * @property + * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.imag + * + */ + +static CYTHON_INLINE double __pyx_f_7cpython_7complex_7complex_4imag_imag(PyComplexObject *__pyx_v_self) { + double __pyx_r; + + /* "cpython/complex.pxd":24 + * @property + * cdef inline double imag(self) noexcept: + * return self.cval.imag # <<<<<<<<<<<<<< + * + * # PyTypeObject PyComplex_Type + */ + __pyx_r = __pyx_v_self->cval.imag; + goto __pyx_L0; + + /* "cpython/complex.pxd":23 + * + * @property + * cdef inline double imag(self) noexcept: # <<<<<<<<<<<<<< + * return self.cval.imag + * + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cpython/contextvars.pxd":112 + * + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, + */ + +static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value *__pyx_optional_args) { + PyObject *__pyx_v_default_value = ((PyObject *)Py_None); + PyObject *__pyx_v_value; + PyObject *__pyx_v_pyvalue = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_value", 1); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default_value = __pyx_optional_args->default_value; + } + } + + /* "cpython/contextvars.pxd":117 + * or None if no such value or default was found. + * """ + * cdef PyObject *value = NULL # <<<<<<<<<<<<<< + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: + */ + __pyx_v_value = NULL; + + /* "cpython/contextvars.pxd":118 + * """ + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) # <<<<<<<<<<<<<< + * if value is NULL: + * # context variable does not have a default + */ + __pyx_t_1 = PyContextVar_Get(__pyx_v_var, NULL, (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 118, __pyx_L1_error) + + /* "cpython/contextvars.pxd":119 + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: # <<<<<<<<<<<<<< + * # context variable does not have a default + * pyvalue = default_value + */ + __pyx_t_2 = (__pyx_v_value == NULL); + if (__pyx_t_2) { + + /* "cpython/contextvars.pxd":121 + * if value is NULL: + * # context variable does not have a default + * pyvalue = default_value # <<<<<<<<<<<<<< + * else: + * # value or default value of context variable + */ + __Pyx_INCREF(__pyx_v_default_value); + __pyx_v_pyvalue = __pyx_v_default_value; + + /* "cpython/contextvars.pxd":119 + * cdef PyObject *value = NULL + * PyContextVar_Get(var, NULL, &value) + * if value is NULL: # <<<<<<<<<<<<<< + * # context variable does not have a default + * pyvalue = default_value + */ + goto __pyx_L3; + } + + /* "cpython/contextvars.pxd":124 + * else: + * # value or default value of context variable + * pyvalue = value # <<<<<<<<<<<<<< + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue + */ + /*else*/ { + __pyx_t_3 = ((PyObject *)__pyx_v_value); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_pyvalue = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cpython/contextvars.pxd":125 + * # value or default value of context variable + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' # <<<<<<<<<<<<<< + * return pyvalue + * + */ + Py_XDECREF(__pyx_v_value); + } + __pyx_L3:; + + /* "cpython/contextvars.pxd":126 + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyvalue); + __pyx_r = __pyx_v_pyvalue; + goto __pyx_L0; + + /* "cpython/contextvars.pxd":112 + * + * + * cdef inline object get_value(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the default value of the context variable, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("cpython.contextvars.get_value", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pyvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ + +static CYTHON_INLINE PyObject *__pyx_f_7cpython_11contextvars_get_value_no_default(PyObject *__pyx_v_var, struct __pyx_opt_args_7cpython_11contextvars_get_value_no_default *__pyx_optional_args) { + PyObject *__pyx_v_default_value = ((PyObject *)Py_None); + PyObject *__pyx_v_value; + PyObject *__pyx_v_pyvalue = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_value_no_default", 1); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_default_value = __pyx_optional_args->default_value; + } + } + + /* "cpython/contextvars.pxd":135 + * Ignores the default value of the context variable, if any. + * """ + * cdef PyObject *value = NULL # <<<<<<<<<<<<<< + * PyContextVar_Get(var, default_value, &value) + * # value of context variable or 'default_value' + */ + __pyx_v_value = NULL; + + /* "cpython/contextvars.pxd":136 + * """ + * cdef PyObject *value = NULL + * PyContextVar_Get(var, default_value, &value) # <<<<<<<<<<<<<< + * # value of context variable or 'default_value' + * pyvalue = value + */ + __pyx_t_1 = PyContextVar_Get(__pyx_v_var, ((PyObject *)__pyx_v_default_value), (&__pyx_v_value)); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(4, 136, __pyx_L1_error) + + /* "cpython/contextvars.pxd":138 + * PyContextVar_Get(var, default_value, &value) + * # value of context variable or 'default_value' + * pyvalue = value # <<<<<<<<<<<<<< + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue + */ + __pyx_t_2 = ((PyObject *)__pyx_v_value); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_pyvalue = __pyx_t_2; + __pyx_t_2 = 0; + + /* "cpython/contextvars.pxd":139 + * # value of context variable or 'default_value' + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' # <<<<<<<<<<<<<< + * return pyvalue + */ + Py_XDECREF(__pyx_v_value); + + /* "cpython/contextvars.pxd":140 + * pyvalue = value + * Py_XDECREF(value) # PyContextVar_Get() returned an owned reference as 'PyObject*' + * return pyvalue # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyvalue); + __pyx_r = __pyx_v_pyvalue; + goto __pyx_L0; + + /* "cpython/contextvars.pxd":129 + * + * + * cdef inline object get_value_no_default(var, default_value=None): # <<<<<<<<<<<<<< + * """Return a new reference to the value of the context variable, + * or the provided default value if no such value was found. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("cpython.contextvars.get_value_no_default", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_pyvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":47 + * + * + * def _is_number(e): # <<<<<<<<<<<<<< + * try: + * f = float(e) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_1_is_number(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip__is_number, "_is_number(e)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_1_is_number = {"_is_number", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_1_is_number, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip__is_number}; +static PyObject *__pyx_pw_9pyscipopt_4scip_1_is_number(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_e = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_is_number (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_e,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_e)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 47, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_is_number") < 0)) __PYX_ERR(1, 47, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_e = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_is_number", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 47, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip._is_number", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip__is_number(__pyx_self, __pyx_v_e); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip__is_number(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_e) { + CYTHON_UNUSED double __pyx_v_f; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + double __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_is_number", 1); + + /* "src/pyscipopt/expr.pxi":48 + * + * def _is_number(e): + * try: # <<<<<<<<<<<<<< + * f = float(e) + * return True + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "src/pyscipopt/expr.pxi":49 + * def _is_number(e): + * try: + * f = float(e) # <<<<<<<<<<<<<< + * return True + * except ValueError: # for malformed strings + */ + __pyx_t_4 = __Pyx_PyObject_AsDouble(__pyx_v_e); if (unlikely(__pyx_t_4 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(1, 49, __pyx_L3_error) + __pyx_v_f = __pyx_t_4; + + /* "src/pyscipopt/expr.pxi":50 + * try: + * f = float(e) + * return True # <<<<<<<<<<<<<< + * except ValueError: # for malformed strings + * return False + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L7_try_return; + + /* "src/pyscipopt/expr.pxi":48 + * + * def _is_number(e): + * try: # <<<<<<<<<<<<<< + * f = float(e) + * return True + */ + } + __pyx_L3_error:; + + /* "src/pyscipopt/expr.pxi":51 + * f = float(e) + * return True + * except ValueError: # for malformed strings # <<<<<<<<<<<<<< + * return False + * except TypeError: # for other types (Variable, Expr) + */ + __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError); + if (__pyx_t_5) { + __Pyx_AddTraceback("pyscipopt.scip._is_number", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8) < 0) __PYX_ERR(1, 51, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + + /* "src/pyscipopt/expr.pxi":52 + * return True + * except ValueError: # for malformed strings + * return False # <<<<<<<<<<<<<< + * except TypeError: # for other types (Variable, Expr) + * return False + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L6_except_return; + } + + /* "src/pyscipopt/expr.pxi":53 + * except ValueError: # for malformed strings + * return False + * except TypeError: # for other types (Variable, Expr) # <<<<<<<<<<<<<< + * return False + * + */ + __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_5) { + __Pyx_AddTraceback("pyscipopt.scip._is_number", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(1, 53, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_6); + + /* "src/pyscipopt/expr.pxi":54 + * return False + * except TypeError: # for other types (Variable, Expr) + * return False # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L6_except_return; + } + goto __pyx_L5_except_error; + + /* "src/pyscipopt/expr.pxi":48 + * + * def _is_number(e): + * try: # <<<<<<<<<<<<<< + * f = float(e) + * return True + */ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L7_try_return:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L0; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L0; + } + + /* "src/pyscipopt/expr.pxi":47 + * + * + * def _is_number(e): # <<<<<<<<<<<<<< + * try: + * f = float(e) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip._is_number", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":57 + * + * + * def _expr_richcmp(self, other, op): # <<<<<<<<<<<<<< + * if op == 1: # <= + * if isinstance(other, Expr) or isinstance(other, GenExpr): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3_expr_richcmp(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2_expr_richcmp, "_expr_richcmp(self, other, op)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3_expr_richcmp = {"_expr_richcmp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3_expr_richcmp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2_expr_richcmp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3_expr_richcmp(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_other = 0; + PyObject *__pyx_v_op = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_expr_richcmp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_other,&__pyx_n_s_op,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 57, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_other)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 57, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("_expr_richcmp", 1, 3, 3, 1); __PYX_ERR(1, 57, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_op)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 57, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("_expr_richcmp", 1, 3, 3, 2); __PYX_ERR(1, 57, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_expr_richcmp") < 0)) __PYX_ERR(1, 57, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_self = values[0]; + __pyx_v_other = values[1]; + __pyx_v_op = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_expr_richcmp", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 57, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip._expr_richcmp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2_expr_richcmp(__pyx_self, __pyx_v_self, __pyx_v_other, __pyx_v_op); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2_expr_richcmp(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_expr_richcmp", 1); + + /* "src/pyscipopt/expr.pxi":58 + * + * def _expr_richcmp(self, other, op): + * if op == 1: # <= # <<<<<<<<<<<<<< + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) <= 0.0 + */ + __pyx_t_1 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_op, __pyx_int_1, 1, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 58, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":59 + * def _expr_richcmp(self, other, op): + * if op == 1: # <= + * if isinstance(other, Expr) or isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * return (self - other) <= 0.0 + * elif _is_number(other): + */ + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_Expr); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_GenExpr); + __pyx_t_1 = __pyx_t_2; + __pyx_L5_bool_binop_done:; + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":60 + * if op == 1: # <= + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) <= 0.0 # <<<<<<<<<<<<<< + * elif _is_number(other): + * return ExprCons(self, rhs=float(other)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_self, __pyx_v_other); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_float_0_0, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 60, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":59 + * def _expr_richcmp(self, other, op): + * if op == 1: # <= + * if isinstance(other, Expr) or isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * return (self - other) <= 0.0 + * elif _is_number(other): + */ + } + + /* "src/pyscipopt/expr.pxi":61 + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) <= 0.0 + * elif _is_number(other): # <<<<<<<<<<<<<< + * return ExprCons(self, rhs=float(other)) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_is_number); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_other}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 61, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/expr.pxi":62 + * return (self - other) <= 0.0 + * elif _is_number(other): + * return ExprCons(self, rhs=float(other)) # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self)) __PYX_ERR(1, 62, __pyx_L1_error); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyNumber_Float(__pyx_v_other); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_rhs, __pyx_t_5) < 0) __PYX_ERR(1, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons), __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":61 + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) <= 0.0 + * elif _is_number(other): # <<<<<<<<<<<<<< + * return ExprCons(self, rhs=float(other)) + * else: + */ + } + + /* "src/pyscipopt/expr.pxi":64 + * return ExprCons(self, rhs=float(other)) + * else: + * raise NotImplementedError # <<<<<<<<<<<<<< + * elif op == 5: # >= + * if isinstance(other, Expr) or isinstance(other, GenExpr): + */ + /*else*/ { + __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0); + __PYX_ERR(1, 64, __pyx_L1_error) + } + + /* "src/pyscipopt/expr.pxi":58 + * + * def _expr_richcmp(self, other, op): + * if op == 1: # <= # <<<<<<<<<<<<<< + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) <= 0.0 + */ + } + + /* "src/pyscipopt/expr.pxi":65 + * else: + * raise NotImplementedError + * elif op == 5: # >= # <<<<<<<<<<<<<< + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) >= 0.0 + */ + __pyx_t_1 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_op, __pyx_int_5, 5, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 65, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":66 + * raise NotImplementedError + * elif op == 5: # >= + * if isinstance(other, Expr) or isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * return (self - other) >= 0.0 + * elif _is_number(other): + */ + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_Expr); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_GenExpr); + __pyx_t_1 = __pyx_t_2; + __pyx_L8_bool_binop_done:; + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":67 + * elif op == 5: # >= + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) >= 0.0 # <<<<<<<<<<<<<< + * elif _is_number(other): + * return ExprCons(self, lhs=float(other)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = PyNumber_Subtract(__pyx_v_self, __pyx_v_other); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_float_0_0, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 67, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":66 + * raise NotImplementedError + * elif op == 5: # >= + * if isinstance(other, Expr) or isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * return (self - other) >= 0.0 + * elif _is_number(other): + */ + } + + /* "src/pyscipopt/expr.pxi":68 + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) >= 0.0 + * elif _is_number(other): # <<<<<<<<<<<<<< + * return ExprCons(self, lhs=float(other)) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_is_number); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_other}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/expr.pxi":69 + * return (self - other) >= 0.0 + * elif _is_number(other): + * return ExprCons(self, lhs=float(other)) # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self)) __PYX_ERR(1, 69, __pyx_L1_error); + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyNumber_Float(__pyx_v_other); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_lhs, __pyx_t_4) < 0) __PYX_ERR(1, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons), __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":68 + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) >= 0.0 + * elif _is_number(other): # <<<<<<<<<<<<<< + * return ExprCons(self, lhs=float(other)) + * else: + */ + } + + /* "src/pyscipopt/expr.pxi":71 + * return ExprCons(self, lhs=float(other)) + * else: + * raise NotImplementedError # <<<<<<<<<<<<<< + * elif op == 2: # == + * if isinstance(other, Expr) or isinstance(other, GenExpr): + */ + /*else*/ { + __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0); + __PYX_ERR(1, 71, __pyx_L1_error) + } + + /* "src/pyscipopt/expr.pxi":65 + * else: + * raise NotImplementedError + * elif op == 5: # >= # <<<<<<<<<<<<<< + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) >= 0.0 + */ + } + + /* "src/pyscipopt/expr.pxi":72 + * else: + * raise NotImplementedError + * elif op == 2: # == # <<<<<<<<<<<<<< + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) == 0.0 + */ + __pyx_t_1 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_op, __pyx_int_2, 2, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 72, __pyx_L1_error) + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/expr.pxi":73 + * raise NotImplementedError + * elif op == 2: # == + * if isinstance(other, Expr) or isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * return (self - other) == 0.0 + * elif _is_number(other): + */ + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_Expr); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_GenExpr); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":74 + * elif op == 2: # == + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) == 0.0 # <<<<<<<<<<<<<< + * elif _is_number(other): + * return ExprCons(self, lhs=float(other), rhs=float(other)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyNumber_Subtract(__pyx_v_self, __pyx_v_other); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyFloat_EqObjC(__pyx_t_4, __pyx_float_0_0, 0.0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":73 + * raise NotImplementedError + * elif op == 2: # == + * if isinstance(other, Expr) or isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * return (self - other) == 0.0 + * elif _is_number(other): + */ + } + + /* "src/pyscipopt/expr.pxi":75 + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) == 0.0 + * elif _is_number(other): # <<<<<<<<<<<<<< + * return ExprCons(self, lhs=float(other), rhs=float(other)) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_is_number); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 75, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/expr.pxi":76 + * return (self - other) == 0.0 + * elif _is_number(other): + * return ExprCons(self, lhs=float(other), rhs=float(other)) # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_self)) __PYX_ERR(1, 76, __pyx_L1_error); + __pyx_t_4 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyNumber_Float(__pyx_v_other); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_lhs, __pyx_t_3) < 0) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyNumber_Float(__pyx_v_other); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_rhs, __pyx_t_3) < 0) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons), __pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":75 + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) == 0.0 + * elif _is_number(other): # <<<<<<<<<<<<<< + * return ExprCons(self, lhs=float(other), rhs=float(other)) + * else: + */ + } + + /* "src/pyscipopt/expr.pxi":78 + * return ExprCons(self, lhs=float(other), rhs=float(other)) + * else: + * raise NotImplementedError # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError("Can only support constraints with '<=', '>=', or '=='.") + */ + /*else*/ { + __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0); + __PYX_ERR(1, 78, __pyx_L1_error) + } + + /* "src/pyscipopt/expr.pxi":72 + * else: + * raise NotImplementedError + * elif op == 2: # == # <<<<<<<<<<<<<< + * if isinstance(other, Expr) or isinstance(other, GenExpr): + * return (self - other) == 0.0 + */ + } + + /* "src/pyscipopt/expr.pxi":80 + * raise NotImplementedError + * else: + * raise NotImplementedError("Can only support constraints with '<=', '>=', or '=='.") # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 80, __pyx_L1_error) + } + + /* "src/pyscipopt/expr.pxi":57 + * + * + * def _expr_richcmp(self, other, op): # <<<<<<<<<<<<<< + * if op == 1: # <= + * if isinstance(other, Expr) or isinstance(other, GenExpr): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip._expr_richcmp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":88 + * __slots__ = ('vartuple', 'ptrtuple', 'hashval') + * + * def __init__(self, *vartuple): # <<<<<<<<<<<<<< + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_1__init__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Term___init__, "Term.__init__(self, *vartuple)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Term_1__init__ = {"__init__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Term_1__init__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Term___init__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_1__init__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_vartuple = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_vartuple = __Pyx_ArgsSlice_FASTCALL(__pyx_args, 1, __pyx_nargs); + if (unlikely(!__pyx_v_vartuple)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_v_vartuple); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + default: + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 88, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + const Py_ssize_t used_pos_args = (kwd_pos_args < 1) ? kwd_pos_args : 1; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, used_pos_args, "__init__") < 0)) __PYX_ERR(1, 88, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs < 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 1, __pyx_nargs); __PYX_ERR(1, 88, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_DECREF(__pyx_v_vartuple); __pyx_v_vartuple = 0; + __Pyx_AddTraceback("pyscipopt.scip.Term.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Term___init__(__pyx_self, __pyx_v_self, __pyx_v_vartuple); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_vartuple); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":89 + * + * def __init__(self, *vartuple): + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) # <<<<<<<<<<<<<< + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + * self.hashval = sum(self.ptrtuple) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_8__init___lambda(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Term_8__init___lambda = {"lambda", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Term_8__init___lambda, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_8__init___lambda(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_v = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lambda (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_v,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_v)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 89, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "lambda") < 0)) __PYX_ERR(1, 89, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_v = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lambda", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 89, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Term.__init__.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self, __pyx_v_v); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_lambda_funcdef_lambda(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_v) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lambda", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_ptr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Term.__init__.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_9pyscipopt_4scip_4Term_8__init___3generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "src/pyscipopt/expr.pxi":90 + * def __init__(self, *vartuple): + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) # <<<<<<<<<<<<<< + * self.hashval = sum(self.ptrtuple) + * + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_8__init___1genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct__genexpr(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(1, 90, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_9pyscipopt_4scip_4Term_8__init___3generator, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_Term___init___locals_genexpr, __pyx_n_s_pyscipopt_scip); if (unlikely(!gen)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Term.__init__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_9pyscipopt_4scip_4Term_8__init___3generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *__pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 90, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(1, 90, __pyx_L1_error) } + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 90, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 90, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 90, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 90, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 90, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 90, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_v); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_v, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_v, __pyx_n_s_ptr); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 90, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":88 + * __slots__ = ('vartuple', 'ptrtuple', 'hashval') + * + * def __init__(self, *vartuple): # <<<<<<<<<<<<<< + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_vartuple) { + PyObject *__pyx_gb_9pyscipopt_4scip_4Term_8__init___3generator = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":89 + * + * def __init__(self, *vartuple): + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) # <<<<<<<<<<<<<< + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + * self.hashval = sum(self.ptrtuple) + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_vartuple); + __Pyx_GIVEREF(__pyx_v_vartuple); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_vartuple)) __PYX_ERR(1, 89, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Term_8__init___lambda, 0, __pyx_n_s_Term___init___locals_lambda, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_key, __pyx_t_3) < 0) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_sorted, __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_vartuple, __pyx_t_2) < 0) __PYX_ERR(1, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":90 + * def __init__(self, *vartuple): + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) # <<<<<<<<<<<<<< + * self.hashval = sum(self.ptrtuple) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vartuple); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_pf_9pyscipopt_4scip_4Term_8__init___1genexpr(NULL, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_ptrtuple, __pyx_t_2) < 0) __PYX_ERR(1, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":91 + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + * self.hashval = sum(self.ptrtuple) # <<<<<<<<<<<<<< + * + * def __getitem__(self, idx): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ptrtuple); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_hashval, __pyx_t_3) < 0) __PYX_ERR(1, 91, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":88 + * __slots__ = ('vartuple', 'ptrtuple', 'hashval') + * + * def __init__(self, *vartuple): # <<<<<<<<<<<<<< + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Term.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_gb_9pyscipopt_4scip_4Term_8__init___3generator); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":93 + * self.hashval = sum(self.ptrtuple) + * + * def __getitem__(self, idx): # <<<<<<<<<<<<<< + * return self.vartuple[idx] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_3__getitem__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Term_2__getitem__, "Term.__getitem__(self, idx)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Term_3__getitem__ = {"__getitem__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Term_3__getitem__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Term_2__getitem__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_3__getitem__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_idx = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_idx,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 93, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_idx)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 93, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, 1); __PYX_ERR(1, 93, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__getitem__") < 0)) __PYX_ERR(1, 93, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_idx = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 93, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Term.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Term_2__getitem__(__pyx_self, __pyx_v_self, __pyx_v_idx); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_2__getitem__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_idx) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 1); + + /* "src/pyscipopt/expr.pxi":94 + * + * def __getitem__(self, idx): + * return self.vartuple[idx] # <<<<<<<<<<<<<< + * + * def __hash__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vartuple); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_idx); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":93 + * self.hashval = sum(self.ptrtuple) + * + * def __getitem__(self, idx): # <<<<<<<<<<<<<< + * return self.vartuple[idx] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Term.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":96 + * return self.vartuple[idx] + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return self.hashval + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_5__hash__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Term_4__hash__, "Term.__hash__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Term_5__hash__ = {"__hash__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Term_5__hash__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Term_4__hash__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_5__hash__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 96, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__hash__") < 0)) __PYX_ERR(1, 96, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__hash__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 96, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Term.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Term_4__hash__(__pyx_self, __pyx_v_self); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_4__hash__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__hash__", 1); + + /* "src/pyscipopt/expr.pxi":97 + * + * def __hash__(self): + * return self.hashval # <<<<<<<<<<<<<< + * + * def __eq__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_hashval); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":96 + * return self.vartuple[idx] + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return self.hashval + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Term.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":99 + * return self.hashval + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return self.ptrtuple == other.ptrtuple + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_7__eq__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Term_6__eq__, "Term.__eq__(self, other)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Term_7__eq__ = {"__eq__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Term_7__eq__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Term_6__eq__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_7__eq__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_other = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_other,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 99, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_other)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 99, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__eq__", 1, 2, 2, 1); __PYX_ERR(1, 99, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__eq__") < 0)) __PYX_ERR(1, 99, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_other = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__eq__", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 99, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Term.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Term_6__eq__(__pyx_self, __pyx_v_self, __pyx_v_other); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_6__eq__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "src/pyscipopt/expr.pxi":100 + * + * def __eq__(self, other): + * return self.ptrtuple == other.ptrtuple # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ptrtuple); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_ptrtuple); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 100, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":99 + * return self.hashval + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return self.ptrtuple == other.ptrtuple + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Term.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":102 + * return self.ptrtuple == other.ptrtuple + * + * def __len__(self): # <<<<<<<<<<<<<< + * return len(self.vartuple) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_9__len__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Term_8__len__, "Term.__len__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Term_9__len__ = {"__len__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Term_9__len__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Term_8__len__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_9__len__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 102, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__len__") < 0)) __PYX_ERR(1, 102, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__len__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 102, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Term.__len__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Term_8__len__(__pyx_self, __pyx_v_self); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_8__len__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__len__", 1); + + /* "src/pyscipopt/expr.pxi":103 + * + * def __len__(self): + * return len(self.vartuple) # <<<<<<<<<<<<<< + * + * def __add__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vartuple); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 103, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":102 + * return self.ptrtuple == other.ptrtuple + * + * def __len__(self): # <<<<<<<<<<<<<< + * return len(self.vartuple) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Term.__len__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":105 + * return len(self.vartuple) + * + * def __add__(self, other): # <<<<<<<<<<<<<< + * both = self.vartuple + other.vartuple + * return Term(*both) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_11__add__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Term_10__add__, "Term.__add__(self, other)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Term_11__add__ = {"__add__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Term_11__add__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Term_10__add__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_11__add__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_other = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__add__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_other,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 105, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_other)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 105, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__add__", 1, 2, 2, 1); __PYX_ERR(1, 105, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__add__") < 0)) __PYX_ERR(1, 105, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_other = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__add__", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 105, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Term.__add__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Term_10__add__(__pyx_self, __pyx_v_self, __pyx_v_other); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_10__add__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_both = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__add__", 1); + + /* "src/pyscipopt/expr.pxi":106 + * + * def __add__(self, other): + * both = self.vartuple + other.vartuple # <<<<<<<<<<<<<< + * return Term(*both) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vartuple); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_vartuple); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_both = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":107 + * def __add__(self, other): + * both = self.vartuple + other.vartuple + * return Term(*both) # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Term); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PySequence_Tuple(__pyx_v_both); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":105 + * return len(self.vartuple) + * + * def __add__(self, other): # <<<<<<<<<<<<<< + * both = self.vartuple + other.vartuple + * return Term(*both) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Term.__add__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_both); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":109 + * return Term(*both) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return 'Term(%s)' % ', '.join([str(v) for v in self.vartuple]) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_13__repr__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Term_12__repr__, "Term.__repr__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Term_13__repr__ = {"__repr__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Term_13__repr__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Term_12__repr__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Term_13__repr__(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_self = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_self)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 109, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__repr__") < 0)) __PYX_ERR(1, 109, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_self = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__repr__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 109, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Term.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Term_12__repr__(__pyx_self, __pyx_v_self); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Term_12__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { + PyObject *__pyx_8genexpr1__pyx_v_v = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *(*__pyx_t_5)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":110 + * + * def __repr__(self): + * return 'Term(%s)' % ', '.join([str(v) for v in self.vartuple]) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 110, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vartuple); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 110, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 110, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 110, __pyx_L5_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 110, __pyx_L5_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 110, __pyx_L5_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 110, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 110, __pyx_L5_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely((0 < 0))) __PYX_ERR(1, 110, __pyx_L5_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 110, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_5(__pyx_t_3); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 110, __pyx_L5_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_v, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Str(__pyx_8genexpr1__pyx_v_v); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 110, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 110, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_v); __pyx_8genexpr1__pyx_v_v = 0; + goto __pyx_L9_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_v); __pyx_8genexpr1__pyx_v_v = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + __pyx_t_3 = PyUnicode_Join(__pyx_kp_u__2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyUnicode_Format(__pyx_kp_u_Term_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":109 + * return Term(*both) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return 'Term(%s)' % ', '.join([str(v) for v in self.vartuple]) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Term.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_v); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":116 + * + * # helper function + * def buildGenExprObj(expr): # <<<<<<<<<<<<<< + * """helper function to generate an object of type GenExpr""" + * if _is_number(expr): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5buildGenExprObj(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4buildGenExprObj, "buildGenExprObj(expr)\nhelper function to generate an object of type GenExpr"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5buildGenExprObj = {"buildGenExprObj", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5buildGenExprObj, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4buildGenExprObj}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5buildGenExprObj(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("buildGenExprObj (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 116, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "buildGenExprObj") < 0)) __PYX_ERR(1, 116, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_expr = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("buildGenExprObj", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 116, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.buildGenExprObj", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4buildGenExprObj(__pyx_self, __pyx_v_expr); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4buildGenExprObj(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr) { + PyObject *__pyx_v_sumexpr = NULL; + PyObject *__pyx_v_vars = NULL; + PyObject *__pyx_v_coef = NULL; + struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_varexpr = NULL; + PyObject *__pyx_v_prodexpr = NULL; + PyObject *__pyx_v_v = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("buildGenExprObj", 1); + + /* "src/pyscipopt/expr.pxi":118 + * def buildGenExprObj(expr): + * """helper function to generate an object of type GenExpr""" + * if _is_number(expr): # <<<<<<<<<<<<<< + * return Constant(expr) + * elif isinstance(expr, Expr): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_is_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_expr}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":119 + * """helper function to generate an object of type GenExpr""" + * if _is_number(expr): + * return Constant(expr) # <<<<<<<<<<<<<< + * elif isinstance(expr, Expr): + * # loop over terms and create a sumexpr with the sum of each term + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constant), __pyx_v_expr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":118 + * def buildGenExprObj(expr): + * """helper function to generate an object of type GenExpr""" + * if _is_number(expr): # <<<<<<<<<<<<<< + * return Constant(expr) + * elif isinstance(expr, Expr): + */ + } + + /* "src/pyscipopt/expr.pxi":120 + * if _is_number(expr): + * return Constant(expr) + * elif isinstance(expr, Expr): # <<<<<<<<<<<<<< + * # loop over terms and create a sumexpr with the sum of each term + * # each term is either a variable (which gets transformed into varexpr) + */ + __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_expr, __pyx_ptype_9pyscipopt_4scip_Expr); + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":124 + * # each term is either a variable (which gets transformed into varexpr) + * # or a product of variables (which gets tranformed into a prod) + * sumexpr = SumExpr() # <<<<<<<<<<<<<< + * for vars, coef in expr.terms.items(): + * if len(vars) == 0: + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_SumExpr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_sumexpr = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":125 + * # or a product of variables (which gets tranformed into a prod) + * sumexpr = SumExpr() + * for vars, coef in expr.terms.items(): # <<<<<<<<<<<<<< + * if len(vars) == 0: + * sumexpr += coef + */ + __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_terms); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__pyx_t_2 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 125, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_dict_iterator(__pyx_t_2, 0, __pyx_n_s_items, (&__pyx_t_7), (&__pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + while (1) { + __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_7, &__pyx_t_6, &__pyx_t_3, &__pyx_t_2, NULL, __pyx_t_4); + if (unlikely(__pyx_t_8 == 0)) break; + if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(1, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_vars, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_coef, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":126 + * sumexpr = SumExpr() + * for vars, coef in expr.terms.items(): + * if len(vars) == 0: # <<<<<<<<<<<<<< + * sumexpr += coef + * elif len(vars) == 1: + */ + __pyx_t_9 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 126, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_9 == 0); + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":127 + * for vars, coef in expr.terms.items(): + * if len(vars) == 0: + * sumexpr += coef # <<<<<<<<<<<<<< + * elif len(vars) == 1: + * varexpr = VarExpr(vars[0]) + */ + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_sumexpr, __pyx_v_coef); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_sumexpr, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":126 + * sumexpr = SumExpr() + * for vars, coef in expr.terms.items(): + * if len(vars) == 0: # <<<<<<<<<<<<<< + * sumexpr += coef + * elif len(vars) == 1: + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/expr.pxi":128 + * if len(vars) == 0: + * sumexpr += coef + * elif len(vars) == 1: # <<<<<<<<<<<<<< + * varexpr = VarExpr(vars[0]) + * sumexpr += coef * varexpr + */ + __pyx_t_9 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(1, 128, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_9 == 1); + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":129 + * sumexpr += coef + * elif len(vars) == 1: + * varexpr = VarExpr(vars[0]) # <<<<<<<<<<<<<< + * sumexpr += coef * varexpr + * else: + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_vars, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_VarExpr), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_varexpr, ((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":130 + * elif len(vars) == 1: + * varexpr = VarExpr(vars[0]) + * sumexpr += coef * varexpr # <<<<<<<<<<<<<< + * else: + * prodexpr = ProdExpr() + */ + __pyx_t_3 = PyNumber_Multiply(__pyx_v_coef, ((PyObject *)__pyx_v_varexpr)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_sumexpr, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_sumexpr, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":128 + * if len(vars) == 0: + * sumexpr += coef + * elif len(vars) == 1: # <<<<<<<<<<<<<< + * varexpr = VarExpr(vars[0]) + * sumexpr += coef * varexpr + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/expr.pxi":132 + * sumexpr += coef * varexpr + * else: + * prodexpr = ProdExpr() # <<<<<<<<<<<<<< + * for v in vars: + * varexpr = VarExpr(v) + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ProdExpr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_prodexpr, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":133 + * else: + * prodexpr = ProdExpr() + * for v in vars: # <<<<<<<<<<<<<< + * varexpr = VarExpr(v) + * prodexpr *= varexpr + */ + if (likely(PyList_CheckExact(__pyx_v_vars)) || PyTuple_CheckExact(__pyx_v_vars)) { + __pyx_t_2 = __pyx_v_vars; __Pyx_INCREF(__pyx_t_2); + __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_vars); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 133, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 133, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_3); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(1, 133, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 133, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_3); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(1, 133, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_10(__pyx_t_2); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 133, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":134 + * prodexpr = ProdExpr() + * for v in vars: + * varexpr = VarExpr(v) # <<<<<<<<<<<<<< + * prodexpr *= varexpr + * sumexpr += coef * prodexpr + */ + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_VarExpr), __pyx_v_v); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_varexpr, ((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":135 + * for v in vars: + * varexpr = VarExpr(v) + * prodexpr *= varexpr # <<<<<<<<<<<<<< + * sumexpr += coef * prodexpr + * return sumexpr + */ + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_v_prodexpr, ((PyObject *)__pyx_v_varexpr)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_prodexpr, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":133 + * else: + * prodexpr = ProdExpr() + * for v in vars: # <<<<<<<<<<<<<< + * varexpr = VarExpr(v) + * prodexpr *= varexpr + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":136 + * varexpr = VarExpr(v) + * prodexpr *= varexpr + * sumexpr += coef * prodexpr # <<<<<<<<<<<<<< + * return sumexpr + * else: + */ + __pyx_t_2 = PyNumber_Multiply(__pyx_v_coef, __pyx_v_prodexpr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_sumexpr, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_sumexpr, __pyx_t_3); + __pyx_t_3 = 0; + } + __pyx_L6:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":137 + * prodexpr *= varexpr + * sumexpr += coef * prodexpr + * return sumexpr # <<<<<<<<<<<<<< + * else: + * assert isinstance(expr, GenExpr) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_sumexpr); + __pyx_r = __pyx_v_sumexpr; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":120 + * if _is_number(expr): + * return Constant(expr) + * elif isinstance(expr, Expr): # <<<<<<<<<<<<<< + * # loop over terms and create a sumexpr with the sum of each term + * # each term is either a variable (which gets transformed into varexpr) + */ + } + + /* "src/pyscipopt/expr.pxi":139 + * return sumexpr + * else: + * assert isinstance(expr, GenExpr) # <<<<<<<<<<<<<< + * return expr + * + */ + /*else*/ { + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_expr, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (unlikely(!__pyx_t_5)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 139, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 139, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":140 + * else: + * assert isinstance(expr, GenExpr) + * return expr # <<<<<<<<<<<<<< + * + * ##@details Polynomial expressions of variables with operator overloading. \n + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_expr); + __pyx_r = __pyx_v_expr; + goto __pyx_L0; + } + + /* "src/pyscipopt/expr.pxi":116 + * + * # helper function + * def buildGenExprObj(expr): # <<<<<<<<<<<<<< + * """helper function to generate an object of type GenExpr""" + * if _is_number(expr): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.buildGenExprObj", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_sumexpr); + __Pyx_XDECREF(__pyx_v_vars); + __Pyx_XDECREF(__pyx_v_coef); + __Pyx_XDECREF((PyObject *)__pyx_v_varexpr); + __Pyx_XDECREF(__pyx_v_prodexpr); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":146 + * cdef class Expr: + * + * def __init__(self, terms=None): # <<<<<<<<<<<<<< + * '''terms is a dict of variables to coefficients. + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Expr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Expr___init__, "terms is a dict of variables to coefficients.\n\n CONST is used as key for the constant term."); +#if CYTHON_UPDATE_DESCRIPTOR_DOC +struct wrapperbase __pyx_wrapperbase_9pyscipopt_4scip_4Expr___init__; +#endif +static int __pyx_pw_9pyscipopt_4scip_4Expr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_terms = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_terms,0}; + values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_terms); + if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 146, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 146, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_terms = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 1, __pyx_nargs); __PYX_ERR(1, 146, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Expr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr___init__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), __pyx_v_terms); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Expr___init__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_terms) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":150 + * + * CONST is used as key for the constant term.''' + * self.terms = {} if terms is None else terms # <<<<<<<<<<<<<< + * + * if len(self.terms) == 0: + */ + __pyx_t_2 = (__pyx_v_terms == Py_None); + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_v_terms); + __pyx_t_1 = __pyx_v_terms; + } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->terms); + __Pyx_DECREF(__pyx_v_self->terms); + __pyx_v_self->terms = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":152 + * self.terms = {} if terms is None else terms + * + * if len(self.terms) == 0: # <<<<<<<<<<<<<< + * self.terms[CONST] = 0.0 + * + */ + __pyx_t_1 = __pyx_v_self->terms; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = (__pyx_t_4 == 0); + if (__pyx_t_2) { + + /* "src/pyscipopt/expr.pxi":153 + * + * if len(self.terms) == 0: + * self.terms[CONST] = 0.0 # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CONST); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyObject_SetItem(__pyx_v_self->terms, __pyx_t_1, __pyx_float_0_0) < 0))) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":152 + * self.terms = {} if terms is None else terms + * + * if len(self.terms) == 0: # <<<<<<<<<<<<<< + * self.terms[CONST] = 0.0 + * + */ + } + + /* "src/pyscipopt/expr.pxi":146 + * cdef class Expr: + * + * def __init__(self, terms=None): # <<<<<<<<<<<<<< + * '''terms is a dict of variables to coefficients. + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":155 + * self.terms[CONST] = 0.0 + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if not isinstance(key, Term): + * key = Term(key) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_2__getitem__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_2__getitem__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + __Pyx_INCREF(__pyx_v_key); + + /* "src/pyscipopt/expr.pxi":156 + * + * def __getitem__(self, key): + * if not isinstance(key, Term): # <<<<<<<<<<<<<< + * key = Term(key) + * return self.terms.get(key, 0.0) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Term); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_key, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 156, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (!__pyx_t_2); + if (__pyx_t_3) { + + /* "src/pyscipopt/expr.pxi":157 + * def __getitem__(self, key): + * if not isinstance(key, Term): + * key = Term(key) # <<<<<<<<<<<<<< + * return self.terms.get(key, 0.0) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_Term); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_key}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF_SET(__pyx_v_key, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":156 + * + * def __getitem__(self, key): + * if not isinstance(key, Term): # <<<<<<<<<<<<<< + * key = Term(key) + * return self.terms.get(key, 0.0) + */ + } + + /* "src/pyscipopt/expr.pxi":158 + * if not isinstance(key, Term): + * key = Term(key) + * return self.terms.get(key, 0.0) # <<<<<<<<<<<<<< + * + * def __iter__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->terms, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_key, __pyx_float_0_0}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":155 + * self.terms[CONST] = 0.0 + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if not isinstance(key, Term): + * key = Term(key) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":160 + * return self.terms.get(key, 0.0) + * + * def __iter__(self): # <<<<<<<<<<<<<< + * return iter(self.terms) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_5__iter__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_5__iter__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_4__iter__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_4__iter__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__iter__", 1); + + /* "src/pyscipopt/expr.pxi":161 + * + * def __iter__(self): + * return iter(self.terms) # <<<<<<<<<<<<<< + * + * def __next__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->terms; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":160 + * return self.terms.get(key, 0.0) + * + * def __iter__(self): # <<<<<<<<<<<<<< + * return iter(self.terms) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":163 + * return iter(self.terms) + * + * def __next__(self): # <<<<<<<<<<<<<< + * try: return next(self.terms) + * except: raise StopIteration + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_7__next__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_7__next__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_6__next__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_6__next__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_error_without_exception = 0; /* StopIteration */ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__next__", 1); + + /* "src/pyscipopt/expr.pxi":164 + * + * def __next__(self): + * try: return next(self.terms) # <<<<<<<<<<<<<< + * except: raise StopIteration + * + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __pyx_v_self->terms; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyIter_Next(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 164, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L7_try_return; + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/expr.pxi":165 + * def __next__(self): + * try: return next(self.terms) + * except: raise StopIteration # <<<<<<<<<<<<<< + * + * def __abs__(self): + */ + /*except:*/ { + __Pyx_AddTraceback("pyscipopt.scip.Expr.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(1, 165, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_6); + __pyx_error_without_exception = 1; + goto __pyx_L5_except_error;; + } + + /* "src/pyscipopt/expr.pxi":164 + * + * def __next__(self): + * try: return next(self.terms) # <<<<<<<<<<<<<< + * except: raise StopIteration + * + */ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L7_try_return:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L0; + } + + /* "src/pyscipopt/expr.pxi":163 + * return iter(self.terms) + * + * def __next__(self): # <<<<<<<<<<<<<< + * try: return next(self.terms) + * except: raise StopIteration + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + if (!__pyx_error_without_exception) { + __Pyx_AddTraceback("pyscipopt.scip.Expr.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":167 + * except: raise StopIteration + * + * def __abs__(self): # <<<<<<<<<<<<<< + * return abs(buildGenExprObj(self)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_9__abs__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_9__abs__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__abs__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_8__abs__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_8__abs__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__abs__", 1); + + /* "src/pyscipopt/expr.pxi":168 + * + * def __abs__(self): + * return abs(buildGenExprObj(self)) # <<<<<<<<<<<<<< + * + * def __add__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyNumber_Absolute(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":167 + * except: raise StopIteration + * + * def __abs__(self): # <<<<<<<<<<<<<< + * return abs(buildGenExprObj(self)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__abs__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":170 + * return abs(buildGenExprObj(self)) + * + * def __add__(self, other): # <<<<<<<<<<<<<< + * left = self + * right = other + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_11__add__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_11__add__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__add__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_10__add__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_10__add__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_left = NULL; + PyObject *__pyx_v_right = NULL; + PyObject *__pyx_v_terms = NULL; + PyObject *__pyx_v_v = NULL; + PyObject *__pyx_v_c = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__add__", 1); + + /* "src/pyscipopt/expr.pxi":171 + * + * def __add__(self, other): + * left = self # <<<<<<<<<<<<<< + * right = other + * + */ + __Pyx_INCREF((PyObject *)__pyx_v_self); + __pyx_v_left = ((PyObject *)__pyx_v_self); + + /* "src/pyscipopt/expr.pxi":172 + * def __add__(self, other): + * left = self + * right = other # <<<<<<<<<<<<<< + * + * if _is_number(self): + */ + __Pyx_INCREF(__pyx_v_other); + __pyx_v_right = __pyx_v_other; + + /* "src/pyscipopt/expr.pxi":174 + * right = other + * + * if _is_number(self): # <<<<<<<<<<<<<< + * assert isinstance(other, Expr) + * left,right = right,left + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_is_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 174, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":175 + * + * if _is_number(self): + * assert isinstance(other, Expr) # <<<<<<<<<<<<<< + * left,right = right,left + * terms = left.terms.copy() + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_Expr); + if (unlikely(!__pyx_t_5)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 175, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 175, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":176 + * if _is_number(self): + * assert isinstance(other, Expr) + * left,right = right,left # <<<<<<<<<<<<<< + * terms = left.terms.copy() + * + */ + __pyx_t_6 = __pyx_v_right; + __pyx_t_7 = __pyx_v_left; + __pyx_v_left = __pyx_t_6; + __pyx_t_6 = 0; + __pyx_v_right = __pyx_t_7; + __pyx_t_7 = 0; + + /* "src/pyscipopt/expr.pxi":174 + * right = other + * + * if _is_number(self): # <<<<<<<<<<<<<< + * assert isinstance(other, Expr) + * left,right = right,left + */ + } + + /* "src/pyscipopt/expr.pxi":177 + * assert isinstance(other, Expr) + * left,right = right,left + * terms = left.terms.copy() # <<<<<<<<<<<<<< + * + * if isinstance(right, Expr): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_terms); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_terms = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":179 + * terms = left.terms.copy() + * + * if isinstance(right, Expr): # <<<<<<<<<<<<<< + * # merge the terms by component-wise addition + * for v,c in right.terms.items(): + */ + __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_right, __pyx_ptype_9pyscipopt_4scip_Expr); + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":181 + * if isinstance(right, Expr): + * # merge the terms by component-wise addition + * for v,c in right.terms.items(): # <<<<<<<<<<<<<< + * terms[v] = terms.get(v, 0.0) + c + * elif _is_number(right): + */ + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_terms); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_t_3 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_dict_iterator(__pyx_t_3, 0, __pyx_n_s_items, (&__pyx_t_9), (&__pyx_t_4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_2; + __pyx_t_2 = 0; + while (1) { + __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_9, &__pyx_t_8, &__pyx_t_2, &__pyx_t_3, NULL, __pyx_t_4); + if (unlikely(__pyx_t_10 == 0)) break; + if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(1, 181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_c, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":182 + * # merge the terms by component-wise addition + * for v,c in right.terms.items(): + * terms[v] = terms.get(v, 0.0) + c # <<<<<<<<<<<<<< + * elif _is_number(right): + * c = float(right) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_terms, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_11, __pyx_v_v, __pyx_float_0_0}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_10, 2+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_v_c); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_terms, __pyx_v_v, __pyx_t_2) < 0))) __PYX_ERR(1, 182, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":179 + * terms = left.terms.copy() + * + * if isinstance(right, Expr): # <<<<<<<<<<<<<< + * # merge the terms by component-wise addition + * for v,c in right.terms.items(): + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/expr.pxi":183 + * for v,c in right.terms.items(): + * terms[v] = terms.get(v, 0.0) + c + * elif _is_number(right): # <<<<<<<<<<<<<< + * c = float(right) + * terms[CONST] = terms.get(CONST, 0.0) + c + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_is_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_right}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 183, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":184 + * terms[v] = terms.get(v, 0.0) + c + * elif _is_number(right): + * c = float(right) # <<<<<<<<<<<<<< + * terms[CONST] = terms.get(CONST, 0.0) + c + * elif isinstance(right, GenExpr): + */ + __pyx_t_1 = __Pyx_PyNumber_Float(__pyx_v_right); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_c = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":185 + * elif _is_number(right): + * c = float(right) + * terms[CONST] = terms.get(CONST, 0.0) + c # <<<<<<<<<<<<<< + * elif isinstance(right, GenExpr): + * return buildGenExprObj(left) + right + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_terms, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_CONST); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_11 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_11, __pyx_t_3, __pyx_float_0_0}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_c); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CONST); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyObject_SetItem(__pyx_v_terms, __pyx_t_1, __pyx_t_2) < 0))) __PYX_ERR(1, 185, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":183 + * for v,c in right.terms.items(): + * terms[v] = terms.get(v, 0.0) + c + * elif _is_number(right): # <<<<<<<<<<<<<< + * c = float(right) + * terms[CONST] = terms.get(CONST, 0.0) + c + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/expr.pxi":186 + * c = float(right) + * terms[CONST] = terms.get(CONST, 0.0) + c + * elif isinstance(right, GenExpr): # <<<<<<<<<<<<<< + * return buildGenExprObj(left) + right + * else: + */ + __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_right, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (likely(__pyx_t_5)) { + + /* "src/pyscipopt/expr.pxi":187 + * terms[CONST] = terms.get(CONST, 0.0) + c + * elif isinstance(right, GenExpr): + * return buildGenExprObj(left) + right # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_left}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_v_right); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":186 + * c = float(right) + * terms[CONST] = terms.get(CONST, 0.0) + c + * elif isinstance(right, GenExpr): # <<<<<<<<<<<<<< + * return buildGenExprObj(left) + right + * else: + */ + } + + /* "src/pyscipopt/expr.pxi":189 + * return buildGenExprObj(left) + right + * else: + * raise NotImplementedError # <<<<<<<<<<<<<< + * return Expr(terms) + * + */ + /*else*/ { + __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0); + __PYX_ERR(1, 189, __pyx_L1_error) + } + __pyx_L4:; + + /* "src/pyscipopt/expr.pxi":190 + * else: + * raise NotImplementedError + * return Expr(terms) # <<<<<<<<<<<<<< + * + * def __iadd__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr), __pyx_v_terms); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":170 + * return abs(buildGenExprObj(self)) + * + * def __add__(self, other): # <<<<<<<<<<<<<< + * left = self + * right = other + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__add__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_left); + __Pyx_XDECREF(__pyx_v_right); + __Pyx_XDECREF(__pyx_v_terms); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XDECREF(__pyx_v_c); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":192 + * return Expr(terms) + * + * def __iadd__(self, other): # <<<<<<<<<<<<<< + * if isinstance(other, Expr): + * for v,c in other.terms.items(): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_13__iadd__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_13__iadd__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__iadd__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_12__iadd__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_12__iadd__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_v = NULL; + PyObject *__pyx_v_c = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__iadd__", 1); + + /* "src/pyscipopt/expr.pxi":193 + * + * def __iadd__(self, other): + * if isinstance(other, Expr): # <<<<<<<<<<<<<< + * for v,c in other.terms.items(): + * self.terms[v] = self.terms.get(v, 0.0) + c + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_Expr); + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":194 + * def __iadd__(self, other): + * if isinstance(other, Expr): + * for v,c in other.terms.items(): # <<<<<<<<<<<<<< + * self.terms[v] = self.terms.get(v, 0.0) + c + * elif _is_number(other): + */ + __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_terms); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__pyx_t_6 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 194, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_dict_iterator(__pyx_t_6, 0, __pyx_n_s_items, (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_7; + __pyx_t_7 = 0; + while (1) { + __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_4, &__pyx_t_3, &__pyx_t_7, &__pyx_t_6, NULL, __pyx_t_5); + if (unlikely(__pyx_t_8 == 0)) break; + if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(1, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_v_c, __pyx_t_6); + __pyx_t_6 = 0; + + /* "src/pyscipopt/expr.pxi":195 + * if isinstance(other, Expr): + * for v,c in other.terms.items(): + * self.terms[v] = self.terms.get(v, 0.0) + c # <<<<<<<<<<<<<< + * elif _is_number(other): + * c = float(other) + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->terms, __pyx_n_s_get); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_v_v, __pyx_float_0_0}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_7 = PyNumber_Add(__pyx_t_6, __pyx_v_c); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_self->terms, __pyx_v_v, __pyx_t_7) < 0))) __PYX_ERR(1, 195, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":193 + * + * def __iadd__(self, other): + * if isinstance(other, Expr): # <<<<<<<<<<<<<< + * for v,c in other.terms.items(): + * self.terms[v] = self.terms.get(v, 0.0) + c + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":196 + * for v,c in other.terms.items(): + * self.terms[v] = self.terms.get(v, 0.0) + c + * elif _is_number(other): # <<<<<<<<<<<<<< + * c = float(other) + * self.terms[CONST] = self.terms.get(CONST, 0.0) + c + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_is_number); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_other}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 196, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":197 + * self.terms[v] = self.terms.get(v, 0.0) + c + * elif _is_number(other): + * c = float(other) # <<<<<<<<<<<<<< + * self.terms[CONST] = self.terms.get(CONST, 0.0) + c + * elif isinstance(other, GenExpr): + */ + __pyx_t_2 = __Pyx_PyNumber_Float(__pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_c = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":198 + * elif _is_number(other): + * c = float(other) + * self.terms[CONST] = self.terms.get(CONST, 0.0) + c # <<<<<<<<<<<<<< + * elif isinstance(other, GenExpr): + * # is no longer in place, might affect performance? + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->terms, __pyx_n_s_get); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_CONST); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_6, __pyx_float_0_0}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_7 = PyNumber_Add(__pyx_t_2, __pyx_v_c); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_CONST); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely((PyObject_SetItem(__pyx_v_self->terms, __pyx_t_2, __pyx_t_7) < 0))) __PYX_ERR(1, 198, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/expr.pxi":196 + * for v,c in other.terms.items(): + * self.terms[v] = self.terms.get(v, 0.0) + c + * elif _is_number(other): # <<<<<<<<<<<<<< + * c = float(other) + * self.terms[CONST] = self.terms.get(CONST, 0.0) + c + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":199 + * c = float(other) + * self.terms[CONST] = self.terms.get(CONST, 0.0) + c + * elif isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * # is no longer in place, might affect performance? + * # can't do `self = buildGenExprObj(self) + other` since I get + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/expr.pxi":203 + * # can't do `self = buildGenExprObj(self) + other` since I get + * # TypeError: Cannot convert pyscipopt.scip.SumExpr to pyscipopt.scip.Expr + * return buildGenExprObj(self) + other # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, ((PyObject *)__pyx_v_self)}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyNumber_Add(__pyx_t_7, __pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":199 + * c = float(other) + * self.terms[CONST] = self.terms.get(CONST, 0.0) + c + * elif isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * # is no longer in place, might affect performance? + * # can't do `self = buildGenExprObj(self) + other` since I get + */ + } + + /* "src/pyscipopt/expr.pxi":205 + * return buildGenExprObj(self) + other + * else: + * raise NotImplementedError # <<<<<<<<<<<<<< + * return self + * + */ + /*else*/ { + __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0); + __PYX_ERR(1, 205, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/expr.pxi":206 + * else: + * raise NotImplementedError + * return self # <<<<<<<<<<<<<< + * + * def __mul__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":192 + * return Expr(terms) + * + * def __iadd__(self, other): # <<<<<<<<<<<<<< + * if isinstance(other, Expr): + * for v,c in other.terms.items(): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__iadd__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XDECREF(__pyx_v_c); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":208 + * return self + * + * def __mul__(self, other): # <<<<<<<<<<<<<< + * if _is_number(other): + * f = float(other) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_15__mul__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_15__mul__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__mul__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_14__mul__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_14__mul__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + double __pyx_v_f; + PyObject *__pyx_v_terms = NULL; + PyObject *__pyx_v_v1 = NULL; + PyObject *__pyx_v_c1 = NULL; + PyObject *__pyx_v_v2 = NULL; + PyObject *__pyx_v_c2 = NULL; + PyObject *__pyx_v_v = NULL; + PyObject *__pyx_8genexpr2__pyx_v_v = NULL; + PyObject *__pyx_8genexpr2__pyx_v_c = NULL; + PyObject *__pyx_8genexpr3__pyx_v_v = NULL; + PyObject *__pyx_8genexpr3__pyx_v_c = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + double __pyx_t_6; + Py_ssize_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + Py_ssize_t __pyx_t_11; + Py_ssize_t __pyx_t_12; + int __pyx_t_13; + PyObject *__pyx_t_14 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__mul__", 1); + + /* "src/pyscipopt/expr.pxi":209 + * + * def __mul__(self, other): + * if _is_number(other): # <<<<<<<<<<<<<< + * f = float(other) + * return Expr({v:f*c for v,c in self.terms.items()}) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_is_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":210 + * def __mul__(self, other): + * if _is_number(other): + * f = float(other) # <<<<<<<<<<<<<< + * return Expr({v:f*c for v,c in self.terms.items()}) + * elif _is_number(self): + */ + __pyx_t_6 = __Pyx_PyObject_AsDouble(__pyx_v_other); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(1, 210, __pyx_L1_error) + __pyx_v_f = __pyx_t_6; + + /* "src/pyscipopt/expr.pxi":211 + * if _is_number(other): + * f = float(other) + * return Expr({v:f*c for v,c in self.terms.items()}) # <<<<<<<<<<<<<< + * elif _is_number(self): + * f = float(self) + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 211, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = 0; + if (unlikely(__pyx_v_self->terms == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 211, __pyx_L6_error) + } + __pyx_t_3 = __Pyx_dict_iterator(__pyx_v_self->terms, 0, __pyx_n_s_items, (&__pyx_t_8), (&__pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 211, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_3; + __pyx_t_3 = 0; + while (1) { + __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_8, &__pyx_t_7, &__pyx_t_3, &__pyx_t_9, NULL, __pyx_t_4); + if (unlikely(__pyx_t_10 == 0)) break; + if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(1, 211, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_9); + __Pyx_XDECREF_SET(__pyx_8genexpr2__pyx_v_v, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_8genexpr2__pyx_v_c, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_f); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 211, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_9, __pyx_8genexpr2__pyx_v_c); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 211, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr2__pyx_v_v, (PyObject*)__pyx_t_3))) __PYX_ERR(1, 211, __pyx_L6_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_c); __pyx_8genexpr2__pyx_v_c = 0; + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_v); __pyx_8genexpr2__pyx_v_v = 0; + goto __pyx_L9_exit_scope; + __pyx_L6_error:; + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_c); __pyx_8genexpr2__pyx_v_c = 0; + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_v); __pyx_8genexpr2__pyx_v_v = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":209 + * + * def __mul__(self, other): + * if _is_number(other): # <<<<<<<<<<<<<< + * f = float(other) + * return Expr({v:f*c for v,c in self.terms.items()}) + */ + } + + /* "src/pyscipopt/expr.pxi":212 + * f = float(other) + * return Expr({v:f*c for v,c in self.terms.items()}) + * elif _is_number(self): # <<<<<<<<<<<<<< + * f = float(self) + * return Expr({v:f*c for v,c in other.terms.items()}) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_is_number); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 212, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":213 + * return Expr({v:f*c for v,c in self.terms.items()}) + * elif _is_number(self): + * f = float(self) # <<<<<<<<<<<<<< + * return Expr({v:f*c for v,c in other.terms.items()}) + * elif isinstance(other, Expr): + */ + __pyx_t_6 = __Pyx_PyObject_AsDouble(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(1, 213, __pyx_L1_error) + __pyx_v_f = __pyx_t_6; + + /* "src/pyscipopt/expr.pxi":214 + * elif _is_number(self): + * f = float(self) + * return Expr({v:f*c for v,c in other.terms.items()}) # <<<<<<<<<<<<<< + * elif isinstance(other, Expr): + * terms = {} + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 214, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_terms); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 214, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_t_3 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 214, __pyx_L12_error) + } + __pyx_t_9 = __Pyx_dict_iterator(__pyx_t_3, 0, __pyx_n_s_items, (&__pyx_t_7), (&__pyx_t_4)); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 214, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_9; + __pyx_t_9 = 0; + while (1) { + __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_7, &__pyx_t_8, &__pyx_t_9, &__pyx_t_3, NULL, __pyx_t_4); + if (unlikely(__pyx_t_10 == 0)) break; + if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(1, 214, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_8genexpr3__pyx_v_v, __pyx_t_9); + __pyx_t_9 = 0; + __Pyx_XDECREF_SET(__pyx_8genexpr3__pyx_v_c, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 214, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = PyNumber_Multiply(__pyx_t_3, __pyx_8genexpr3__pyx_v_c); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 214, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_8genexpr3__pyx_v_v, (PyObject*)__pyx_t_9))) __PYX_ERR(1, 214, __pyx_L12_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_c); __pyx_8genexpr3__pyx_v_c = 0; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_v); __pyx_8genexpr3__pyx_v_v = 0; + goto __pyx_L15_exit_scope; + __pyx_L12_error:; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_c); __pyx_8genexpr3__pyx_v_c = 0; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_v); __pyx_8genexpr3__pyx_v_v = 0; + goto __pyx_L1_error; + __pyx_L15_exit_scope:; + } /* exit inner scope */ + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":212 + * f = float(other) + * return Expr({v:f*c for v,c in self.terms.items()}) + * elif _is_number(self): # <<<<<<<<<<<<<< + * f = float(self) + * return Expr({v:f*c for v,c in other.terms.items()}) + */ + } + + /* "src/pyscipopt/expr.pxi":215 + * f = float(self) + * return Expr({v:f*c for v,c in other.terms.items()}) + * elif isinstance(other, Expr): # <<<<<<<<<<<<<< + * terms = {} + * for v1, c1 in self.terms.items(): + */ + __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_Expr); + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":216 + * return Expr({v:f*c for v,c in other.terms.items()}) + * elif isinstance(other, Expr): + * terms = {} # <<<<<<<<<<<<<< + * for v1, c1 in self.terms.items(): + * for v2, c2 in other.terms.items(): + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_terms = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":217 + * elif isinstance(other, Expr): + * terms = {} + * for v1, c1 in self.terms.items(): # <<<<<<<<<<<<<< + * for v2, c2 in other.terms.items(): + * v = v1 + v2 + */ + __pyx_t_7 = 0; + if (unlikely(__pyx_v_self->terms == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 217, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_dict_iterator(__pyx_v_self->terms, 0, __pyx_n_s_items, (&__pyx_t_8), (&__pyx_t_4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_2; + __pyx_t_2 = 0; + while (1) { + __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_8, &__pyx_t_7, &__pyx_t_2, &__pyx_t_9, NULL, __pyx_t_4); + if (unlikely(__pyx_t_10 == 0)) break; + if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(1, 217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_9); + __Pyx_XDECREF_SET(__pyx_v_v1, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_c1, __pyx_t_9); + __pyx_t_9 = 0; + + /* "src/pyscipopt/expr.pxi":218 + * terms = {} + * for v1, c1 in self.terms.items(): + * for v2, c2 in other.terms.items(): # <<<<<<<<<<<<<< + * v = v1 + v2 + * terms[v] = terms.get(v, 0.0) + c1 * c2 + */ + __pyx_t_11 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_terms); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__pyx_t_2 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 218, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_dict_iterator(__pyx_t_2, 0, __pyx_n_s_items, (&__pyx_t_12), (&__pyx_t_10)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_9); + __pyx_t_9 = __pyx_t_3; + __pyx_t_3 = 0; + while (1) { + __pyx_t_13 = __Pyx_dict_iter_next(__pyx_t_9, __pyx_t_12, &__pyx_t_11, &__pyx_t_3, &__pyx_t_2, NULL, __pyx_t_10); + if (unlikely(__pyx_t_13 == 0)) break; + if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(1, 218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_v2, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_c2, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":219 + * for v1, c1 in self.terms.items(): + * for v2, c2 in other.terms.items(): + * v = v1 + v2 # <<<<<<<<<<<<<< + * terms[v] = terms.get(v, 0.0) + c1 * c2 + * return Expr(terms) + */ + __pyx_t_2 = PyNumber_Add(__pyx_v_v1, __pyx_v_v2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":220 + * for v2, c2 in other.terms.items(): + * v = v1 + v2 + * terms[v] = terms.get(v, 0.0) + c1 * c2 # <<<<<<<<<<<<<< + * return Expr(terms) + * elif isinstance(other, GenExpr): + */ + __pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_v_terms, __pyx_v_v, __pyx_float_0_0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_c1, __pyx_v_c2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_14 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_terms, __pyx_v_v, __pyx_t_14) < 0))) __PYX_ERR(1, 220, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":221 + * v = v1 + v2 + * terms[v] = terms.get(v, 0.0) + c1 * c2 + * return Expr(terms) # <<<<<<<<<<<<<< + * elif isinstance(other, GenExpr): + * return buildGenExprObj(self) * other + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr), __pyx_v_terms); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":215 + * f = float(self) + * return Expr({v:f*c for v,c in other.terms.items()}) + * elif isinstance(other, Expr): # <<<<<<<<<<<<<< + * terms = {} + * for v1, c1 in self.terms.items(): + */ + } + + /* "src/pyscipopt/expr.pxi":222 + * terms[v] = terms.get(v, 0.0) + c1 * c2 + * return Expr(terms) + * elif isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * return buildGenExprObj(self) * other + * else: + */ + __pyx_t_5 = __Pyx_TypeCheck(__pyx_v_other, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (likely(__pyx_t_5)) { + + /* "src/pyscipopt/expr.pxi":223 + * return Expr(terms) + * elif isinstance(other, GenExpr): + * return buildGenExprObj(self) * other # <<<<<<<<<<<<<< + * else: + * raise NotImplementedError + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_14 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_14)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_14); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_14, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __pyx_t_9 = PyNumber_Multiply(__pyx_t_1, __pyx_v_other); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_9; + __pyx_t_9 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":222 + * terms[v] = terms.get(v, 0.0) + c1 * c2 + * return Expr(terms) + * elif isinstance(other, GenExpr): # <<<<<<<<<<<<<< + * return buildGenExprObj(self) * other + * else: + */ + } + + /* "src/pyscipopt/expr.pxi":225 + * return buildGenExprObj(self) * other + * else: + * raise NotImplementedError # <<<<<<<<<<<<<< + * + * def __truediv__(self,other): + */ + /*else*/ { + __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0); + __PYX_ERR(1, 225, __pyx_L1_error) + } + + /* "src/pyscipopt/expr.pxi":208 + * return self + * + * def __mul__(self, other): # <<<<<<<<<<<<<< + * if _is_number(other): + * f = float(other) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__mul__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_terms); + __Pyx_XDECREF(__pyx_v_v1); + __Pyx_XDECREF(__pyx_v_c1); + __Pyx_XDECREF(__pyx_v_v2); + __Pyx_XDECREF(__pyx_v_c2); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_v); + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_c); + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_v); + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_c); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":227 + * raise NotImplementedError + * + * def __truediv__(self,other): # <<<<<<<<<<<<<< + * if _is_number(other): + * f = 1.0/float(other) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_17__truediv__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_17__truediv__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__truediv__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_16__truediv__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_16__truediv__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + double __pyx_v_f; + PyObject *__pyx_v_selfexpr = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + double __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__truediv__", 1); + + /* "src/pyscipopt/expr.pxi":228 + * + * def __truediv__(self,other): + * if _is_number(other): # <<<<<<<<<<<<<< + * f = 1.0/float(other) + * return f * self + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_is_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 228, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":229 + * def __truediv__(self,other): + * if _is_number(other): + * f = 1.0/float(other) # <<<<<<<<<<<<<< + * return f * self + * selfexpr = buildGenExprObj(self) + */ + __pyx_t_6 = __Pyx_PyObject_AsDouble(__pyx_v_other); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(1, 229, __pyx_L1_error) + if (unlikely(__pyx_t_6 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(1, 229, __pyx_L1_error) + } + __pyx_v_f = (1.0 / __pyx_t_6); + + /* "src/pyscipopt/expr.pxi":230 + * if _is_number(other): + * f = 1.0/float(other) + * return f * self # <<<<<<<<<<<<<< + * selfexpr = buildGenExprObj(self) + * return selfexpr.__truediv__(other) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":228 + * + * def __truediv__(self,other): + * if _is_number(other): # <<<<<<<<<<<<<< + * f = 1.0/float(other) + * return f * self + */ + } + + /* "src/pyscipopt/expr.pxi":231 + * f = 1.0/float(other) + * return f * self + * selfexpr = buildGenExprObj(self) # <<<<<<<<<<<<<< + * return selfexpr.__truediv__(other) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_v_selfexpr = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":232 + * return f * self + * selfexpr = buildGenExprObj(self) + * return selfexpr.__truediv__(other) # <<<<<<<<<<<<<< + * + * def __rtruediv__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_selfexpr, __pyx_n_s_truediv); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":227 + * raise NotImplementedError + * + * def __truediv__(self,other): # <<<<<<<<<<<<<< + * if _is_number(other): + * f = 1.0/float(other) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__truediv__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_selfexpr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":234 + * return selfexpr.__truediv__(other) + * + * def __rtruediv__(self, other): # <<<<<<<<<<<<<< + * ''' other / self ''' + * if _is_number(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_19__rtruediv__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Expr_18__rtruediv__, " other / self "); +#if CYTHON_UPDATE_DESCRIPTOR_DOC +struct wrapperbase __pyx_wrapperbase_9pyscipopt_4scip_4Expr_18__rtruediv__; +#endif +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_19__rtruediv__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__rtruediv__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_18__rtruediv__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_18__rtruediv__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + double __pyx_v_f; + PyObject *__pyx_v_otherexpr = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + double __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__rtruediv__", 1); + + /* "src/pyscipopt/expr.pxi":236 + * def __rtruediv__(self, other): + * ''' other / self ''' + * if _is_number(self): # <<<<<<<<<<<<<< + * f = 1.0/float(self) + * return f * other + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_is_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 236, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":237 + * ''' other / self ''' + * if _is_number(self): + * f = 1.0/float(self) # <<<<<<<<<<<<<< + * return f * other + * otherexpr = buildGenExprObj(other) + */ + __pyx_t_6 = __Pyx_PyObject_AsDouble(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_6 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(1, 237, __pyx_L1_error) + if (unlikely(__pyx_t_6 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(1, 237, __pyx_L1_error) + } + __pyx_v_f = (1.0 / __pyx_t_6); + + /* "src/pyscipopt/expr.pxi":238 + * if _is_number(self): + * f = 1.0/float(self) + * return f * other # <<<<<<<<<<<<<< + * otherexpr = buildGenExprObj(other) + * return otherexpr.__truediv__(self) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_f); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_t_1, __pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":236 + * def __rtruediv__(self, other): + * ''' other / self ''' + * if _is_number(self): # <<<<<<<<<<<<<< + * f = 1.0/float(self) + * return f * other + */ + } + + /* "src/pyscipopt/expr.pxi":239 + * f = 1.0/float(self) + * return f * other + * otherexpr = buildGenExprObj(other) # <<<<<<<<<<<<<< + * return otherexpr.__truediv__(self) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_v_otherexpr = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":240 + * return f * other + * otherexpr = buildGenExprObj(other) + * return otherexpr.__truediv__(self) # <<<<<<<<<<<<<< + * + * def __pow__(self, other, modulo): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_otherexpr, __pyx_n_s_truediv); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":234 + * return selfexpr.__truediv__(other) + * + * def __rtruediv__(self, other): # <<<<<<<<<<<<<< + * ''' other / self ''' + * if _is_number(self): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__rtruediv__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_otherexpr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":242 + * return otherexpr.__truediv__(self) + * + * def __pow__(self, other, modulo): # <<<<<<<<<<<<<< + * if float(other).is_integer() and other >= 0: + * exp = int(other) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_21__pow__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_modulo); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_21__pow__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_modulo) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pow__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_20__pow__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other), ((PyObject *)__pyx_v_modulo)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_20__pow__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other, CYTHON_UNUSED PyObject *__pyx_v_modulo) { + PyObject *__pyx_v_exp = NULL; + PyObject *__pyx_v_res = NULL; + CYTHON_UNUSED PyObject *__pyx_v__ = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pow__", 1); + + /* "src/pyscipopt/expr.pxi":243 + * + * def __pow__(self, other, modulo): + * if float(other).is_integer() and other >= 0: # <<<<<<<<<<<<<< + * exp = int(other) + * else: # need to transform to GenExpr + */ + __pyx_t_3 = __Pyx_PyNumber_Float(__pyx_v_other); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_is_integer); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 243, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_6) { + } else { + __pyx_t_1 = __pyx_t_6; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = PyObject_RichCompare(__pyx_v_other, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 243, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 243, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_6; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":244 + * def __pow__(self, other, modulo): + * if float(other).is_integer() and other >= 0: + * exp = int(other) # <<<<<<<<<<<<<< + * else: # need to transform to GenExpr + * return buildGenExprObj(self)**other + */ + __pyx_t_2 = __Pyx_PyNumber_Int(__pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_exp = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":243 + * + * def __pow__(self, other, modulo): + * if float(other).is_integer() and other >= 0: # <<<<<<<<<<<<<< + * exp = int(other) + * else: # need to transform to GenExpr + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":246 + * exp = int(other) + * else: # need to transform to GenExpr + * return buildGenExprObj(self)**other # <<<<<<<<<<<<<< + * + * res = 1 + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_4 = PyNumber_Power(__pyx_t_2, __pyx_v_other, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + __pyx_L3:; + + /* "src/pyscipopt/expr.pxi":248 + * return buildGenExprObj(self)**other + * + * res = 1 # <<<<<<<<<<<<<< + * for _ in range(exp): + * res *= self + */ + __Pyx_INCREF(__pyx_int_1); + __pyx_v_res = __pyx_int_1; + + /* "src/pyscipopt/expr.pxi":249 + * + * res = 1 + * for _ in range(exp): # <<<<<<<<<<<<<< + * res *= self + * return res + */ + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_v_exp); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { + __pyx_t_2 = __pyx_t_4; __Pyx_INCREF(__pyx_t_2); + __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 249, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 249, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(1, 249, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 249, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(1, 249, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_8(__pyx_t_2); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 249, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/expr.pxi":250 + * res = 1 + * for _ in range(exp): + * res *= self # <<<<<<<<<<<<<< + * return res + * + */ + __pyx_t_4 = PyNumber_InPlaceMultiply(__pyx_v_res, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_res, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/expr.pxi":249 + * + * res = 1 + * for _ in range(exp): # <<<<<<<<<<<<<< + * res *= self + * return res + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":251 + * for _ in range(exp): + * res *= self + * return res # <<<<<<<<<<<<<< + * + * def __neg__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_res); + __pyx_r = __pyx_v_res; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":242 + * return otherexpr.__truediv__(self) + * + * def __pow__(self, other, modulo): # <<<<<<<<<<<<<< + * if float(other).is_integer() and other >= 0: + * exp = int(other) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__pow__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_exp); + __Pyx_XDECREF(__pyx_v_res); + __Pyx_XDECREF(__pyx_v__); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":253 + * return res + * + * def __neg__(self): # <<<<<<<<<<<<<< + * return Expr({v:-c for v,c in self.terms.items()}) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_23__neg__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_23__neg__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__neg__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_22__neg__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_22__neg__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_8genexpr4__pyx_v_v = NULL; + PyObject *__pyx_8genexpr4__pyx_v_c = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__neg__", 1); + + /* "src/pyscipopt/expr.pxi":254 + * + * def __neg__(self): + * return Expr({v:-c for v,c in self.terms.items()}) # <<<<<<<<<<<<<< + * + * def __sub__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 254, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = 0; + if (unlikely(__pyx_v_self->terms == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 254, __pyx_L5_error) + } + __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_self->terms, 0, __pyx_n_s_items, (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 254, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = 0; + while (1) { + __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_4, &__pyx_t_3, &__pyx_t_6, &__pyx_t_7, NULL, __pyx_t_5); + if (unlikely(__pyx_t_8 == 0)) break; + if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(1, 254, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_8genexpr4__pyx_v_v, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_8genexpr4__pyx_v_c, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Negative(__pyx_8genexpr4__pyx_v_c); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 254, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr4__pyx_v_v, (PyObject*)__pyx_t_7))) __PYX_ERR(1, 254, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_c); __pyx_8genexpr4__pyx_v_c = 0; + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_v); __pyx_8genexpr4__pyx_v_v = 0; + goto __pyx_L8_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_c); __pyx_8genexpr4__pyx_v_c = 0; + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_v); __pyx_8genexpr4__pyx_v_v = 0; + goto __pyx_L1_error; + __pyx_L8_exit_scope:; + } /* exit inner scope */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":253 + * return res + * + * def __neg__(self): # <<<<<<<<<<<<<< + * return Expr({v:-c for v,c in self.terms.items()}) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__neg__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_v); + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_c); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":256 + * return Expr({v:-c for v,c in self.terms.items()}) + * + * def __sub__(self, other): # <<<<<<<<<<<<<< + * return self + (-other) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_25__sub__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_25__sub__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__sub__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_24__sub__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_24__sub__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__sub__", 1); + + /* "src/pyscipopt/expr.pxi":257 + * + * def __sub__(self, other): + * return self + (-other) # <<<<<<<<<<<<<< + * + * def __radd__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Negative(__pyx_v_other); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Add(((PyObject *)__pyx_v_self), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":256 + * return Expr({v:-c for v,c in self.terms.items()}) + * + * def __sub__(self, other): # <<<<<<<<<<<<<< + * return self + (-other) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__sub__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":259 + * return self + (-other) + * + * def __radd__(self, other): # <<<<<<<<<<<<<< + * return self.__add__(other) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_27__radd__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_27__radd__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__radd__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_26__radd__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_26__radd__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__radd__", 1); + + /* "src/pyscipopt/expr.pxi":260 + * + * def __radd__(self, other): + * return self.__add__(other) # <<<<<<<<<<<<<< + * + * def __rmul__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":259 + * return self + (-other) + * + * def __radd__(self, other): # <<<<<<<<<<<<<< + * return self.__add__(other) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__radd__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":262 + * return self.__add__(other) + * + * def __rmul__(self, other): # <<<<<<<<<<<<<< + * return self.__mul__(other) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_29__rmul__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_29__rmul__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__rmul__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_28__rmul__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_28__rmul__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__rmul__", 1); + + /* "src/pyscipopt/expr.pxi":263 + * + * def __rmul__(self, other): + * return self.__mul__(other) # <<<<<<<<<<<<<< + * + * def __rsub__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_mul); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":262 + * return self.__add__(other) + * + * def __rmul__(self, other): # <<<<<<<<<<<<<< + * return self.__mul__(other) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__rmul__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":265 + * return self.__mul__(other) + * + * def __rsub__(self, other): # <<<<<<<<<<<<<< + * return -1.0 * self + other + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_31__rsub__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_31__rsub__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__rsub__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_30__rsub__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_30__rsub__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__rsub__", 1); + + /* "src/pyscipopt/expr.pxi":266 + * + * def __rsub__(self, other): + * return -1.0 * self + other # <<<<<<<<<<<<<< + * + * def __richcmp__(self, other, op): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Multiply(__pyx_float_neg_1_0, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":265 + * return self.__mul__(other) + * + * def __rsub__(self, other): # <<<<<<<<<<<<<< + * return -1.0 * self + other + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__rsub__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":268 + * return -1.0 * self + other + * + * def __richcmp__(self, other, op): # <<<<<<<<<<<<<< + * '''turn it into a constraint''' + * return _expr_richcmp(self, other, op) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_33__richcmp__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, int __pyx_arg_op); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_33__richcmp__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, int __pyx_arg_op) { + PyObject *__pyx_v_op = 0; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__richcmp__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_v_op = __Pyx_PyInt_From_int(__pyx_arg_op); if (unlikely(!__pyx_v_op)) __PYX_ERR(1, 268, __pyx_L3_error) + __Pyx_GOTREF(__pyx_v_op); + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pyscipopt.scip.Expr.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_32__richcmp__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_other), ((PyObject *)__pyx_v_op)); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_op); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_32__richcmp__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__richcmp__", 1); + + /* "src/pyscipopt/expr.pxi":270 + * def __richcmp__(self, other, op): + * '''turn it into a constraint''' + * return _expr_richcmp(self, other, op) # <<<<<<<<<<<<<< + * + * def normalize(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_expr_richcmp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_3, ((PyObject *)__pyx_v_self), __pyx_v_other, __pyx_v_op}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 3+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":268 + * return -1.0 * self + other + * + * def __richcmp__(self, other, op): # <<<<<<<<<<<<<< + * '''turn it into a constraint''' + * return _expr_richcmp(self, other, op) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":272 + * return _expr_richcmp(self, other, op) + * + * def normalize(self): # <<<<<<<<<<<<<< + * '''remove terms with coefficient of 0''' + * self.terms = {t:c for (t,c) in self.terms.items() if c != 0.0} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_35normalize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Expr_34normalize, "Expr.normalize(self)\nremove terms with coefficient of 0"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Expr_35normalize = {"normalize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Expr_35normalize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Expr_34normalize}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_35normalize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("normalize (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("normalize", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "normalize", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_34normalize(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_34normalize(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_8genexpr5__pyx_v_t = NULL; + PyObject *__pyx_8genexpr5__pyx_v_c = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("normalize", 1); + + /* "src/pyscipopt/expr.pxi":274 + * def normalize(self): + * '''remove terms with coefficient of 0''' + * self.terms = {t:c for (t,c) in self.terms.items() if c != 0.0} # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 274, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = 0; + if (unlikely(__pyx_v_self->terms == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(1, 274, __pyx_L5_error) + } + __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_self->terms, 0, __pyx_n_s_items, (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 274, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = 0; + while (1) { + __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_4, &__pyx_t_3, &__pyx_t_6, &__pyx_t_7, NULL, __pyx_t_5); + if (unlikely(__pyx_t_8 == 0)) break; + if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(1, 274, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_8genexpr5__pyx_v_t, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_8genexpr5__pyx_v_c, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_9 = (__Pyx_PyFloat_BoolNeObjC(__pyx_8genexpr5__pyx_v_c, __pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(1, 274, __pyx_L5_error) + if (__pyx_t_9) { + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr5__pyx_v_t, (PyObject*)__pyx_8genexpr5__pyx_v_c))) __PYX_ERR(1, 274, __pyx_L5_error) + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_c); __pyx_8genexpr5__pyx_v_c = 0; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_t); __pyx_8genexpr5__pyx_v_t = 0; + goto __pyx_L9_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_c); __pyx_8genexpr5__pyx_v_c = 0; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_t); __pyx_8genexpr5__pyx_v_t = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->terms); + __Pyx_DECREF(__pyx_v_self->terms); + __pyx_v_self->terms = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":272 + * return _expr_richcmp(self, other, op) + * + * def normalize(self): # <<<<<<<<<<<<<< + * '''remove terms with coefficient of 0''' + * self.terms = {t:c for (t,c) in self.terms.items() if c != 0.0} + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Expr.normalize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_t); + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_c); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":276 + * self.terms = {t:c for (t,c) in self.terms.items() if c != 0.0} + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return 'Expr(%s)' % repr(self.terms) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_37__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_37__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_36__repr__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_36__repr__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":277 + * + * def __repr__(self): + * return 'Expr(%s)' % repr(self.terms) # <<<<<<<<<<<<<< + * + * def degree(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->terms; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = PyObject_Repr(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_Expr_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":276 + * self.terms = {t:c for (t,c) in self.terms.items() if c != 0.0} + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return 'Expr(%s)' % repr(self.terms) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":279 + * return 'Expr(%s)' % repr(self.terms) + * + * def degree(self): # <<<<<<<<<<<<<< + * '''computes highest degree of terms''' + * if len(self.terms) == 0: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_39degree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Expr_38degree, "Expr.degree(self)\ncomputes highest degree of terms"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Expr_39degree = {"degree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Expr_39degree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Expr_38degree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_39degree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("degree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("degree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "degree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_38degree(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_9pyscipopt_4scip_4Expr_6degree_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "src/pyscipopt/expr.pxi":284 + * return 0 + * else: + * return max(len(v) for v in self.terms) # <<<<<<<<<<<<<< + * + * + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_6degree_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_1_genexpr(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(1, 284, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_9pyscipopt_4scip_4Expr_6degree_2generator1, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_degree_locals_genexpr, __pyx_n_s_pyscipopt_scip); if (unlikely(!gen)) __PYX_ERR(1, 284, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Expr.degree.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_9pyscipopt_4scip_4Expr_6degree_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 284, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(1, 284, __pyx_L1_error) } + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 284, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 284, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 284, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 284, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 284, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 284, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_v); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_v, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_5 = PyObject_Length(__pyx_cur_scope->__pyx_v_v); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 284, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 284, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":279 + * return 'Expr(%s)' % repr(self.terms) + * + * def degree(self): # <<<<<<<<<<<<<< + * '''computes highest degree of terms''' + * if len(self.terms) == 0: + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_38degree(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_gb_9pyscipopt_4scip_4Expr_6degree_2generator1 = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("degree", 1); + + /* "src/pyscipopt/expr.pxi":281 + * def degree(self): + * '''computes highest degree of terms''' + * if len(self.terms) == 0: # <<<<<<<<<<<<<< + * return 0 + * else: + */ + __pyx_t_1 = __pyx_v_self->terms; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(1, 281, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 == 0); + if (__pyx_t_3) { + + /* "src/pyscipopt/expr.pxi":282 + * '''computes highest degree of terms''' + * if len(self.terms) == 0: + * return 0 # <<<<<<<<<<<<<< + * else: + * return max(len(v) for v in self.terms) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_int_0); + __pyx_r = __pyx_int_0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":281 + * def degree(self): + * '''computes highest degree of terms''' + * if len(self.terms) == 0: # <<<<<<<<<<<<<< + * return 0 + * else: + */ + } + + /* "src/pyscipopt/expr.pxi":284 + * return 0 + * else: + * return max(len(v) for v in self.terms) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_pf_9pyscipopt_4scip_4Expr_6degree_genexpr(NULL, __pyx_v_self->terms); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_max, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/expr.pxi":279 + * return 'Expr(%s)' % repr(self.terms) + * + * def degree(self): # <<<<<<<<<<<<<< + * '''computes highest degree of terms''' + * if len(self.terms) == 0: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Expr.degree", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_gb_9pyscipopt_4scip_4Expr_6degree_2generator1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1867 + * + * cdef class Expr: + * cdef public terms # <<<<<<<<<<<<<< + * + * cdef class Event: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_5terms_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_5terms_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_5terms___get__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_5terms___get__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->terms); + __pyx_r = __pyx_v_self->terms; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Expr_5terms_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Expr_5terms_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_5terms_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Expr_5terms_2__set__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->terms); + __Pyx_DECREF(__pyx_v_self->terms); + __pyx_v_self->terms = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Expr_5terms_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Expr_5terms_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_5terms_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Expr_5terms_4__del__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->terms); + __Pyx_DECREF(__pyx_v_self->terms); + __pyx_v_self->terms = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_41__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Expr_40__reduce_cython__, "Expr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Expr_41__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Expr_41__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Expr_40__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_41__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_40__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_40__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.terms,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->terms); + __Pyx_GIVEREF(__pyx_v_self->terms); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->terms)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.terms,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.terms,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.terms is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.terms,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.terms is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, None), state + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_self->terms != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.terms is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.terms is not None + * if use_setstate: + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Expr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_85795681); + __Pyx_GIVEREF(__pyx_int_85795681); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_85795681)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.terms is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, None), state + * else: + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Expr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Expr); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_85795681); + __Pyx_GIVEREF(__pyx_int_85795681); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_85795681)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Expr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_43__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Expr_42__setstate_cython__, "Expr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Expr_43__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Expr_43__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Expr_42__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Expr_43__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Expr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Expr_42__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Expr_42__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Expr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Expr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Expr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Expr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":293 + * cdef public _rhs + * + * def __init__(self, expr, lhs=None, rhs=None): # <<<<<<<<<<<<<< + * self.expr = expr + * self._lhs = lhs + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_expr = 0; + PyObject *__pyx_v_lhs = 0; + PyObject *__pyx_v_rhs = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,&__pyx_n_s_lhs,&__pyx_n_s_rhs,0}; + values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + values[2] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 293, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lhs); + if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 293, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rhs); + if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 293, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 293, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_expr = values[0]; + __pyx_v_lhs = values[1]; + __pyx_v_rhs = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, __pyx_nargs); __PYX_ERR(1, 293, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons___init__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self), __pyx_v_expr, __pyx_v_lhs, __pyx_v_rhs); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ExprCons___init__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_expr, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":294 + * + * def __init__(self, expr, lhs=None, rhs=None): + * self.expr = expr # <<<<<<<<<<<<<< + * self._lhs = lhs + * self._rhs = rhs + */ + __Pyx_INCREF(__pyx_v_expr); + __Pyx_GIVEREF(__pyx_v_expr); + __Pyx_GOTREF(__pyx_v_self->expr); + __Pyx_DECREF(__pyx_v_self->expr); + __pyx_v_self->expr = __pyx_v_expr; + + /* "src/pyscipopt/expr.pxi":295 + * def __init__(self, expr, lhs=None, rhs=None): + * self.expr = expr + * self._lhs = lhs # <<<<<<<<<<<<<< + * self._rhs = rhs + * assert not (lhs is None and rhs is None) + */ + __Pyx_INCREF(__pyx_v_lhs); + __Pyx_GIVEREF(__pyx_v_lhs); + __Pyx_GOTREF(__pyx_v_self->_lhs); + __Pyx_DECREF(__pyx_v_self->_lhs); + __pyx_v_self->_lhs = __pyx_v_lhs; + + /* "src/pyscipopt/expr.pxi":296 + * self.expr = expr + * self._lhs = lhs + * self._rhs = rhs # <<<<<<<<<<<<<< + * assert not (lhs is None and rhs is None) + * self.normalize() + */ + __Pyx_INCREF(__pyx_v_rhs); + __Pyx_GIVEREF(__pyx_v_rhs); + __Pyx_GOTREF(__pyx_v_self->_rhs); + __Pyx_DECREF(__pyx_v_self->_rhs); + __pyx_v_self->_rhs = __pyx_v_rhs; + + /* "src/pyscipopt/expr.pxi":297 + * self._lhs = lhs + * self._rhs = rhs + * assert not (lhs is None and rhs is None) # <<<<<<<<<<<<<< + * self.normalize() + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_2 = (__pyx_v_lhs == Py_None); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_rhs == Py_None); + __pyx_t_1 = __pyx_t_2; + __pyx_L3_bool_binop_done:; + __pyx_t_2 = (!__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 297, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 297, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":298 + * self._rhs = rhs + * assert not (lhs is None and rhs is None) + * self.normalize() # <<<<<<<<<<<<<< + * + * def normalize(self): + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_normalize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":293 + * cdef public _rhs + * + * def __init__(self, expr, lhs=None, rhs=None): # <<<<<<<<<<<<<< + * self.expr = expr + * self._lhs = lhs + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":300 + * self.normalize() + * + * def normalize(self): # <<<<<<<<<<<<<< + * '''move constant terms in expression to bounds''' + * if isinstance(self.expr, Expr): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_3normalize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8ExprCons_2normalize, "ExprCons.normalize(self)\nmove constant terms in expression to bounds"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8ExprCons_3normalize = {"normalize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ExprCons_3normalize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ExprCons_2normalize}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_3normalize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("normalize (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("normalize", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "normalize", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_2normalize(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_2normalize(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + PyObject *__pyx_v_c = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("normalize", 1); + + /* "src/pyscipopt/expr.pxi":302 + * def normalize(self): + * '''move constant terms in expression to bounds''' + * if isinstance(self.expr, Expr): # <<<<<<<<<<<<<< + * c = self.expr[CONST] + * self.expr -= c + */ + __pyx_t_1 = __pyx_v_self->expr; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __Pyx_TypeCheck(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Expr); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "src/pyscipopt/expr.pxi":303 + * '''move constant terms in expression to bounds''' + * if isinstance(self.expr, Expr): + * c = self.expr[CONST] # <<<<<<<<<<<<<< + * self.expr -= c + * assert self.expr[CONST] == 0.0 + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_CONST); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 303, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_self->expr, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 303, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_c = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":304 + * if isinstance(self.expr, Expr): + * c = self.expr[CONST] + * self.expr -= c # <<<<<<<<<<<<<< + * assert self.expr[CONST] == 0.0 + * self.expr.normalize() + */ + __pyx_t_3 = PyNumber_InPlaceSubtract(__pyx_v_self->expr, __pyx_v_c); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->expr); + __Pyx_DECREF(__pyx_v_self->expr); + __pyx_v_self->expr = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":305 + * c = self.expr[CONST] + * self.expr -= c + * assert self.expr[CONST] == 0.0 # <<<<<<<<<<<<<< + * self.expr.normalize() + * else: + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_CONST); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_self->expr, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = (__Pyx_PyFloat_BoolEqObjC(__pyx_t_1, __pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 305, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 305, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 305, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":306 + * self.expr -= c + * assert self.expr[CONST] == 0.0 + * self.expr.normalize() # <<<<<<<<<<<<<< + * else: + * assert isinstance(self.expr, GenExpr) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->expr, __pyx_n_s_normalize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":302 + * def normalize(self): + * '''move constant terms in expression to bounds''' + * if isinstance(self.expr, Expr): # <<<<<<<<<<<<<< + * c = self.expr[CONST] + * self.expr -= c + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":308 + * self.expr.normalize() + * else: + * assert isinstance(self.expr, GenExpr) # <<<<<<<<<<<<<< + * return + * + */ + /*else*/ { + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __pyx_v_self->expr; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = __Pyx_TypeCheck(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_GenExpr); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 308, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 308, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":309 + * else: + * assert isinstance(self.expr, GenExpr) + * return # <<<<<<<<<<<<<< + * + * if not self._lhs is None: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + } + __pyx_L3:; + + /* "src/pyscipopt/expr.pxi":311 + * return + * + * if not self._lhs is None: # <<<<<<<<<<<<<< + * self._lhs -= c + * if not self._rhs is None: + */ + __pyx_t_2 = (__pyx_v_self->_lhs != Py_None); + if (__pyx_t_2) { + + /* "src/pyscipopt/expr.pxi":312 + * + * if not self._lhs is None: + * self._lhs -= c # <<<<<<<<<<<<<< + * if not self._rhs is None: + * self._rhs -= c + */ + __pyx_t_1 = PyNumber_InPlaceSubtract(__pyx_v_self->_lhs, __pyx_v_c); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_lhs); + __Pyx_DECREF(__pyx_v_self->_lhs); + __pyx_v_self->_lhs = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":311 + * return + * + * if not self._lhs is None: # <<<<<<<<<<<<<< + * self._lhs -= c + * if not self._rhs is None: + */ + } + + /* "src/pyscipopt/expr.pxi":313 + * if not self._lhs is None: + * self._lhs -= c + * if not self._rhs is None: # <<<<<<<<<<<<<< + * self._rhs -= c + * + */ + __pyx_t_2 = (__pyx_v_self->_rhs != Py_None); + if (__pyx_t_2) { + + /* "src/pyscipopt/expr.pxi":314 + * self._lhs -= c + * if not self._rhs is None: + * self._rhs -= c # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = PyNumber_InPlaceSubtract(__pyx_v_self->_rhs, __pyx_v_c); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_rhs); + __Pyx_DECREF(__pyx_v_self->_rhs); + __pyx_v_self->_rhs = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":313 + * if not self._lhs is None: + * self._lhs -= c + * if not self._rhs is None: # <<<<<<<<<<<<<< + * self._rhs -= c + * + */ + } + + /* "src/pyscipopt/expr.pxi":300 + * self.normalize() + * + * def normalize(self): # <<<<<<<<<<<<<< + * '''move constant terms in expression to bounds''' + * if isinstance(self.expr, Expr): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.normalize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_c); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":317 + * + * + * def __richcmp__(self, other, op): # <<<<<<<<<<<<<< + * '''turn it into a constraint''' + * if op == 1: # <= + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_5__richcmp__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, int __pyx_arg_op); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_5__richcmp__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, int __pyx_arg_op) { + PyObject *__pyx_v_op = 0; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__richcmp__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_v_op = __Pyx_PyInt_From_int(__pyx_arg_op); if (unlikely(!__pyx_v_op)) __PYX_ERR(1, 317, __pyx_L3_error) + __Pyx_GOTREF(__pyx_v_op); + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4__richcmp__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self), ((PyObject *)__pyx_v_other), ((PyObject *)__pyx_v_op)); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_op); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_4__richcmp__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__richcmp__", 1); + + /* "src/pyscipopt/expr.pxi":319 + * def __richcmp__(self, other, op): + * '''turn it into a constraint''' + * if op == 1: # <= # <<<<<<<<<<<<<< + * if not self._rhs is None: + * raise TypeError('ExprCons already has upper bound') + */ + __pyx_t_1 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_op, __pyx_int_1, 1, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 319, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/expr.pxi":320 + * '''turn it into a constraint''' + * if op == 1: # <= + * if not self._rhs is None: # <<<<<<<<<<<<<< + * raise TypeError('ExprCons already has upper bound') + * assert self._rhs is None + */ + __pyx_t_1 = (__pyx_v_self->_rhs != Py_None); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/expr.pxi":321 + * if op == 1: # <= + * if not self._rhs is None: + * raise TypeError('ExprCons already has upper bound') # <<<<<<<<<<<<<< + * assert self._rhs is None + * assert not self._lhs is None + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 321, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":320 + * '''turn it into a constraint''' + * if op == 1: # <= + * if not self._rhs is None: # <<<<<<<<<<<<<< + * raise TypeError('ExprCons already has upper bound') + * assert self._rhs is None + */ + } + + /* "src/pyscipopt/expr.pxi":322 + * if not self._rhs is None: + * raise TypeError('ExprCons already has upper bound') + * assert self._rhs is None # <<<<<<<<<<<<<< + * assert not self._lhs is None + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (__pyx_v_self->_rhs == Py_None); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 322, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 322, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":323 + * raise TypeError('ExprCons already has upper bound') + * assert self._rhs is None + * assert not self._lhs is None # <<<<<<<<<<<<<< + * + * if not _is_number(other): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (__pyx_v_self->_lhs != Py_None); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 323, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 323, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":325 + * assert not self._lhs is None + * + * if not _is_number(other): # <<<<<<<<<<<<<< + * raise TypeError('Ranged ExprCons is not well defined!') + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_is_number); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_other}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 325, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = (!__pyx_t_1); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/expr.pxi":326 + * + * if not _is_number(other): + * raise TypeError('Ranged ExprCons is not well defined!') # <<<<<<<<<<<<<< + * + * return ExprCons(self.expr, lhs=self._lhs, rhs=float(other)) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 326, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":325 + * assert not self._lhs is None + * + * if not _is_number(other): # <<<<<<<<<<<<<< + * raise TypeError('Ranged ExprCons is not well defined!') + * + */ + } + + /* "src/pyscipopt/expr.pxi":328 + * raise TypeError('Ranged ExprCons is not well defined!') + * + * return ExprCons(self.expr, lhs=self._lhs, rhs=float(other)) # <<<<<<<<<<<<<< + * elif op == 5: # >= + * if not self._lhs is None: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_self->expr); + __Pyx_GIVEREF(__pyx_v_self->expr); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_self->expr)) __PYX_ERR(1, 328, __pyx_L1_error); + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lhs, __pyx_v_self->_lhs) < 0) __PYX_ERR(1, 328, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyNumber_Float(__pyx_v_other); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_rhs, __pyx_t_4) < 0) __PYX_ERR(1, 328, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":319 + * def __richcmp__(self, other, op): + * '''turn it into a constraint''' + * if op == 1: # <= # <<<<<<<<<<<<<< + * if not self._rhs is None: + * raise TypeError('ExprCons already has upper bound') + */ + } + + /* "src/pyscipopt/expr.pxi":329 + * + * return ExprCons(self.expr, lhs=self._lhs, rhs=float(other)) + * elif op == 5: # >= # <<<<<<<<<<<<<< + * if not self._lhs is None: + * raise TypeError('ExprCons already has lower bound') + */ + __pyx_t_6 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_op, __pyx_int_5, 5, 0)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 329, __pyx_L1_error) + if (likely(__pyx_t_6)) { + + /* "src/pyscipopt/expr.pxi":330 + * return ExprCons(self.expr, lhs=self._lhs, rhs=float(other)) + * elif op == 5: # >= + * if not self._lhs is None: # <<<<<<<<<<<<<< + * raise TypeError('ExprCons already has lower bound') + * assert self._lhs is None + */ + __pyx_t_6 = (__pyx_v_self->_lhs != Py_None); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/expr.pxi":331 + * elif op == 5: # >= + * if not self._lhs is None: + * raise TypeError('ExprCons already has lower bound') # <<<<<<<<<<<<<< + * assert self._lhs is None + * assert not self._rhs is None + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 331, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":330 + * return ExprCons(self.expr, lhs=self._lhs, rhs=float(other)) + * elif op == 5: # >= + * if not self._lhs is None: # <<<<<<<<<<<<<< + * raise TypeError('ExprCons already has lower bound') + * assert self._lhs is None + */ + } + + /* "src/pyscipopt/expr.pxi":332 + * if not self._lhs is None: + * raise TypeError('ExprCons already has lower bound') + * assert self._lhs is None # <<<<<<<<<<<<<< + * assert not self._rhs is None + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_6 = (__pyx_v_self->_lhs == Py_None); + if (unlikely(!__pyx_t_6)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 332, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 332, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":333 + * raise TypeError('ExprCons already has lower bound') + * assert self._lhs is None + * assert not self._rhs is None # <<<<<<<<<<<<<< + * + * if not _is_number(other): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_6 = (__pyx_v_self->_rhs != Py_None); + if (unlikely(!__pyx_t_6)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 333, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 333, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":335 + * assert not self._rhs is None + * + * if not _is_number(other): # <<<<<<<<<<<<<< + * raise TypeError('Ranged ExprCons is not well defined!') + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_is_number); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_other}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 335, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = (!__pyx_t_6); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/expr.pxi":336 + * + * if not _is_number(other): + * raise TypeError('Ranged ExprCons is not well defined!') # <<<<<<<<<<<<<< + * + * return ExprCons(self.expr, lhs=float(other), rhs=self._rhs) + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 336, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":335 + * assert not self._rhs is None + * + * if not _is_number(other): # <<<<<<<<<<<<<< + * raise TypeError('Ranged ExprCons is not well defined!') + * + */ + } + + /* "src/pyscipopt/expr.pxi":338 + * raise TypeError('Ranged ExprCons is not well defined!') + * + * return ExprCons(self.expr, lhs=float(other), rhs=self._rhs) # <<<<<<<<<<<<<< + * else: + * raise TypeError + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_self->expr); + __Pyx_GIVEREF(__pyx_v_self->expr); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_self->expr)) __PYX_ERR(1, 338, __pyx_L1_error); + __pyx_t_3 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyNumber_Float(__pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_lhs, __pyx_t_2) < 0) __PYX_ERR(1, 338, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_rhs, __pyx_v_self->_rhs) < 0) __PYX_ERR(1, 338, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons), __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":329 + * + * return ExprCons(self.expr, lhs=self._lhs, rhs=float(other)) + * elif op == 5: # >= # <<<<<<<<<<<<<< + * if not self._lhs is None: + * raise TypeError('ExprCons already has lower bound') + */ + } + + /* "src/pyscipopt/expr.pxi":340 + * return ExprCons(self.expr, lhs=float(other), rhs=self._rhs) + * else: + * raise TypeError # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + /*else*/ { + __Pyx_Raise(__pyx_builtin_TypeError, 0, 0, 0); + __PYX_ERR(1, 340, __pyx_L1_error) + } + + /* "src/pyscipopt/expr.pxi":317 + * + * + * def __richcmp__(self, other, op): # <<<<<<<<<<<<<< + * '''turn it into a constraint''' + * if op == 1: # <= + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":342 + * raise TypeError + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return 'ExprCons(%s, %s, %s)' % (self.expr, self._lhs, self._rhs) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_7__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_7__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_6__repr__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_6__repr__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_UCS4 __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":343 + * + * def __repr__(self): + * return 'ExprCons(%s, %s, %s)' % (self.expr, self._lhs, self._rhs) # <<<<<<<<<<<<<< + * + * def __nonzero__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = 127; + __Pyx_INCREF(__pyx_kp_u_ExprCons); + __pyx_t_2 += 9; + __Pyx_GIVEREF(__pyx_kp_u_ExprCons); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_ExprCons); + __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_v_self->expr), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3; + __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_INCREF(__pyx_kp_u__2); + __pyx_t_2 += 2; + __Pyx_GIVEREF(__pyx_kp_u__2); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_kp_u__2); + __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_v_self->_lhs), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3; + __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_INCREF(__pyx_kp_u__2); + __pyx_t_2 += 2; + __Pyx_GIVEREF(__pyx_kp_u__2); + PyTuple_SET_ITEM(__pyx_t_1, 4, __pyx_kp_u__2); + __pyx_t_4 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_v_self->_rhs), __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_3) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_3; + __pyx_t_2 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_1, 5, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_INCREF(__pyx_kp_u__6); + __pyx_t_2 += 1; + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_1, 6, __pyx_kp_u__6); + __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_1, 7, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":342 + * raise TypeError + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return 'ExprCons(%s, %s, %s)' % (self.expr, self._lhs, self._rhs) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":345 + * return 'ExprCons(%s, %s, %s)' % (self.expr, self._lhs, self._rhs) + * + * def __nonzero__(self): # <<<<<<<<<<<<<< + * '''Make sure that equality of expressions is not asserted with ==''' + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_9__nonzero__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_9__nonzero__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__nonzero__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_8__nonzero__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_8__nonzero__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + PyObject *__pyx_v_msg = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__nonzero__", 1); + + /* "src/pyscipopt/expr.pxi":348 + * '''Make sure that equality of expressions is not asserted with ==''' + * + * msg = """Can't evaluate constraints as booleans. # <<<<<<<<<<<<<< + * + * If you want to add a ranged constraint of the form + */ + __Pyx_INCREF(__pyx_kp_u_Can_t_evaluate_constraints_as_bo); + __pyx_v_msg = __pyx_kp_u_Can_t_evaluate_constraints_as_bo; + + /* "src/pyscipopt/expr.pxi":355 + * lhs <= (expression <= rhs) + * """ + * raise TypeError(msg) # <<<<<<<<<<<<<< + * + * def quicksum(termlist): + */ + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_v_msg); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 355, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":345 + * return 'ExprCons(%s, %s, %s)' % (self.expr, self._lhs, self._rhs) + * + * def __nonzero__(self): # <<<<<<<<<<<<<< + * '''Make sure that equality of expressions is not asserted with ==''' + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__nonzero__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":289 + * cdef class ExprCons: + * '''Constraints with a polynomial expressions and lower/upper bounds.''' + * cdef public expr # <<<<<<<<<<<<<< + * cdef public _lhs + * cdef public _rhs + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4expr___get__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_4expr___get__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->expr); + __pyx_r = __pyx_v_self->expr; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4expr_2__set__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4expr_2__set__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->expr); + __Pyx_DECREF(__pyx_v_self->expr); + __pyx_v_self->expr = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4expr_4__del__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4expr_4__del__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->expr); + __Pyx_DECREF(__pyx_v_self->expr); + __pyx_v_self->expr = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":290 + * '''Constraints with a polynomial expressions and lower/upper bounds.''' + * cdef public expr + * cdef public _lhs # <<<<<<<<<<<<<< + * cdef public _rhs + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs___get__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs___get__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_lhs); + __pyx_r = __pyx_v_self->_lhs; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs_2__set__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs_2__set__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->_lhs); + __Pyx_DECREF(__pyx_v_self->_lhs); + __pyx_v_self->_lhs = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs_4__del__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4_lhs_4__del__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_lhs); + __Pyx_DECREF(__pyx_v_self->_lhs); + __pyx_v_self->_lhs = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":291 + * cdef public expr + * cdef public _lhs + * cdef public _rhs # <<<<<<<<<<<<<< + * + * def __init__(self, expr, lhs=None, rhs=None): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs___get__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs___get__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_rhs); + __pyx_r = __pyx_v_self->_rhs; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs_2__set__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs_2__set__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->_rhs); + __Pyx_DECREF(__pyx_v_self->_rhs); + __pyx_v_self->_rhs = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs_4__del__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ExprCons_4_rhs_4__del__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_rhs); + __Pyx_DECREF(__pyx_v_self->_rhs); + __pyx_v_self->_rhs = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_11__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8ExprCons_10__reduce_cython__, "ExprCons.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8ExprCons_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ExprCons_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ExprCons_10__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_11__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_10__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_10__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._lhs, self._rhs, self.expr) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->_lhs); + __Pyx_GIVEREF(__pyx_v_self->_lhs); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->_lhs)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->_rhs); + __Pyx_GIVEREF(__pyx_v_self->_rhs); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->_rhs)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->expr); + __Pyx_GIVEREF(__pyx_v_self->expr); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->expr)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._lhs, self._rhs, self.expr) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self._lhs, self._rhs, self.expr) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._lhs is not None or self._rhs is not None or self.expr is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._lhs, self._rhs, self.expr) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._lhs is not None or self._rhs is not None or self.expr is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, None), state + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->_lhs != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->_rhs != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->expr != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._lhs is not None or self._rhs is not None or self.expr is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._lhs is not None or self._rhs is not None or self.expr is not None + * if use_setstate: + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_ExprCons); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_143015212); + __Pyx_GIVEREF(__pyx_int_143015212); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_143015212)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._lhs is not None or self._rhs is not None or self.expr is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, None), state + * else: + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_ExprCons__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_ExprCons); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_143015212); + __Pyx_GIVEREF(__pyx_int_143015212); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_143015212)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ExprCons__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_13__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8ExprCons_12__setstate_cython__, "ExprCons.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8ExprCons_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ExprCons_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ExprCons_12__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8ExprCons_13__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ExprCons_12__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ExprCons_12__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_ExprCons__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_ExprCons__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ExprCons__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.ExprCons.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":357 + * raise TypeError(msg) + * + * def quicksum(termlist): # <<<<<<<<<<<<<< + * '''add linear expressions and constants much faster than Python's sum + * by avoiding intermediate data structures and adding terms inplace + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7quicksum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6quicksum, "quicksum(termlist)\nadd linear expressions and constants much faster than Python's sum\n by avoiding intermediate data structures and adding terms inplace\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7quicksum = {"quicksum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7quicksum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6quicksum}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7quicksum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_termlist = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("quicksum (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_termlist,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_termlist)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 357, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "quicksum") < 0)) __PYX_ERR(1, 357, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_termlist = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("quicksum", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 357, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.quicksum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6quicksum(__pyx_self, __pyx_v_termlist); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6quicksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_termlist) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_term = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("quicksum", 1); + + /* "src/pyscipopt/expr.pxi":361 + * by avoiding intermediate data structures and adding terms inplace + * ''' + * result = Expr() # <<<<<<<<<<<<<< + * for term in termlist: + * result += term + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":362 + * ''' + * result = Expr() + * for term in termlist: # <<<<<<<<<<<<<< + * result += term + * return result + */ + if (likely(PyList_CheckExact(__pyx_v_termlist)) || PyTuple_CheckExact(__pyx_v_termlist)) { + __pyx_t_1 = __pyx_v_termlist; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_termlist); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 362, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 362, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 362, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 362, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 362, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 362, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_term, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/expr.pxi":363 + * result = Expr() + * for term in termlist: + * result += term # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_result, __pyx_v_term); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/expr.pxi":362 + * ''' + * result = Expr() + * for term in termlist: # <<<<<<<<<<<<<< + * result += term + * return result + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":364 + * for term in termlist: + * result += term + * return result # <<<<<<<<<<<<<< + * + * def quickprod(termlist): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":357 + * raise TypeError(msg) + * + * def quicksum(termlist): # <<<<<<<<<<<<<< + * '''add linear expressions and constants much faster than Python's sum + * by avoiding intermediate data structures and adding terms inplace + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.quicksum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_term); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":366 + * return result + * + * def quickprod(termlist): # <<<<<<<<<<<<<< + * '''multiply linear expressions and constants by avoiding intermediate + * data structures and multiplying terms inplace + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9quickprod(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8quickprod, "quickprod(termlist)\nmultiply linear expressions and constants by avoiding intermediate \n data structures and multiplying terms inplace\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9quickprod = {"quickprod", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9quickprod, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8quickprod}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9quickprod(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_termlist = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("quickprod (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_termlist,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_termlist)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 366, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "quickprod") < 0)) __PYX_ERR(1, 366, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_termlist = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("quickprod", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 366, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.quickprod", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8quickprod(__pyx_self, __pyx_v_termlist); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8quickprod(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_termlist) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_term = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("quickprod", 1); + + /* "src/pyscipopt/expr.pxi":370 + * data structures and multiplying terms inplace + * ''' + * result = Expr() + 1 # <<<<<<<<<<<<<< + * for term in termlist: + * result *= term + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_int_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":371 + * ''' + * result = Expr() + 1 + * for term in termlist: # <<<<<<<<<<<<<< + * result *= term + * return result + */ + if (likely(PyList_CheckExact(__pyx_v_termlist)) || PyTuple_CheckExact(__pyx_v_termlist)) { + __pyx_t_2 = __pyx_v_termlist; __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_termlist); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 371, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 371, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 371, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 371, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(1, 371, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 371, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_term, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":372 + * result = Expr() + 1 + * for term in termlist: + * result *= term # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_term); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":371 + * ''' + * result = Expr() + 1 + * for term in termlist: # <<<<<<<<<<<<<< + * result *= term + * return result + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":373 + * for term in termlist: + * result *= term + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":366 + * return result + * + * def quickprod(termlist): # <<<<<<<<<<<<<< + * '''multiply linear expressions and constants by avoiding intermediate + * data structures and multiplying terms inplace + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.quickprod", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_term); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":400 + * + * + * def __init__(self): # do we need it # <<<<<<<<<<<<<< + * ''' ''' + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7GenExpr___init__, " "); +#if CYTHON_UPDATE_DESCRIPTOR_DOC +struct wrapperbase __pyx_wrapperbase_9pyscipopt_4scip_7GenExpr___init__; +#endif +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr___init__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7GenExpr___init__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + int __pyx_r; + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":403 + * ''' ''' + * + * def __abs__(self): # <<<<<<<<<<<<<< + * return UnaryExpr(Operator.fabs, self) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_3__abs__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_3__abs__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__abs__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_2__abs__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_2__abs__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__abs__", 1); + + /* "src/pyscipopt/expr.pxi":404 + * + * def __abs__(self): + * return UnaryExpr(Operator.fabs, self) # <<<<<<<<<<<<<< + * + * def __add__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_fabs); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2)) __PYX_ERR(1, 404, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self))) __PYX_ERR(1, 404, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":403 + * ''' ''' + * + * def __abs__(self): # <<<<<<<<<<<<<< + * return UnaryExpr(Operator.fabs, self) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__abs__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":406 + * return UnaryExpr(Operator.fabs, self) + * + * def __add__(self, other): # <<<<<<<<<<<<<< + * left = buildGenExprObj(self) + * right = buildGenExprObj(other) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_5__add__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_5__add__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__add__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_4__add__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_4__add__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_left = NULL; + PyObject *__pyx_v_right = NULL; + struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_ans = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__add__", 1); + + /* "src/pyscipopt/expr.pxi":407 + * + * def __add__(self, other): + * left = buildGenExprObj(self) # <<<<<<<<<<<<<< + * right = buildGenExprObj(other) + * ans = SumExpr() + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_left = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":408 + * def __add__(self, other): + * left = buildGenExprObj(self) + * right = buildGenExprObj(other) # <<<<<<<<<<<<<< + * ans = SumExpr() + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_right = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":409 + * left = buildGenExprObj(self) + * right = buildGenExprObj(other) + * ans = SumExpr() # <<<<<<<<<<<<<< + * + * # add left term + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_SumExpr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_ans = ((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":412 + * + * # add left term + * if left.getOp() == Operator.add: # <<<<<<<<<<<<<< + * ans.coefs.extend(left.coefs) + * ans.children.extend(left.children) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_add_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":413 + * # add left term + * if left.getOp() == Operator.add: + * ans.coefs.extend(left.coefs) # <<<<<<<<<<<<<< + * ans.children.extend(left.children) + * ans.constant += left.constant + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ans->coefs, __pyx_n_s_extend); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_coefs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":414 + * if left.getOp() == Operator.add: + * ans.coefs.extend(left.coefs) + * ans.children.extend(left.children) # <<<<<<<<<<<<<< + * ans.constant += left.constant + * elif left.getOp() == Operator.const: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ans->__pyx_base.children, __pyx_n_s_extend); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_children); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":415 + * ans.coefs.extend(left.coefs) + * ans.children.extend(left.children) + * ans.constant += left.constant # <<<<<<<<<<<<<< + * elif left.getOp() == Operator.const: + * ans.constant += left.number + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_constant); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_ans->constant, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_ans->constant); + __Pyx_DECREF(__pyx_v_ans->constant); + __pyx_v_ans->constant = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":412 + * + * # add left term + * if left.getOp() == Operator.add: # <<<<<<<<<<<<<< + * ans.coefs.extend(left.coefs) + * ans.children.extend(left.children) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":416 + * ans.children.extend(left.children) + * ans.constant += left.constant + * elif left.getOp() == Operator.const: # <<<<<<<<<<<<<< + * ans.constant += left.number + * else: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_const); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":417 + * ans.constant += left.constant + * elif left.getOp() == Operator.const: + * ans.constant += left.number # <<<<<<<<<<<<<< + * else: + * ans.coefs.append(1.0) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_ans->constant, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_ans->constant); + __Pyx_DECREF(__pyx_v_ans->constant); + __pyx_v_ans->constant = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":416 + * ans.children.extend(left.children) + * ans.constant += left.constant + * elif left.getOp() == Operator.const: # <<<<<<<<<<<<<< + * ans.constant += left.number + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":419 + * ans.constant += left.number + * else: + * ans.coefs.append(1.0) # <<<<<<<<<<<<<< + * ans.children.append(left) + * + */ + /*else*/ { + __pyx_t_7 = __Pyx_PyObject_Append(__pyx_v_ans->coefs, __pyx_float_1_0); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 419, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":420 + * else: + * ans.coefs.append(1.0) + * ans.children.append(left) # <<<<<<<<<<<<<< + * + * # add right term + */ + __pyx_t_7 = __Pyx_PyObject_Append(__pyx_v_ans->__pyx_base.children, __pyx_v_left); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 420, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/expr.pxi":423 + * + * # add right term + * if right.getOp() == Operator.add: # <<<<<<<<<<<<<< + * ans.coefs.extend(right.coefs) + * ans.children.extend(right.children) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_add_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 423, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 423, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":424 + * # add right term + * if right.getOp() == Operator.add: + * ans.coefs.extend(right.coefs) # <<<<<<<<<<<<<< + * ans.children.extend(right.children) + * ans.constant += right.constant + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ans->coefs, __pyx_n_s_extend); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_coefs); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":425 + * if right.getOp() == Operator.add: + * ans.coefs.extend(right.coefs) + * ans.children.extend(right.children) # <<<<<<<<<<<<<< + * ans.constant += right.constant + * elif right.getOp() == Operator.const: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ans->__pyx_base.children, __pyx_n_s_extend); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_children); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":426 + * ans.coefs.extend(right.coefs) + * ans.children.extend(right.children) + * ans.constant += right.constant # <<<<<<<<<<<<<< + * elif right.getOp() == Operator.const: + * ans.constant += right.number + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_constant); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_ans->constant, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_ans->constant); + __Pyx_DECREF(__pyx_v_ans->constant); + __pyx_v_ans->constant = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":423 + * + * # add right term + * if right.getOp() == Operator.add: # <<<<<<<<<<<<<< + * ans.coefs.extend(right.coefs) + * ans.children.extend(right.children) + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/expr.pxi":427 + * ans.children.extend(right.children) + * ans.constant += right.constant + * elif right.getOp() == Operator.const: # <<<<<<<<<<<<<< + * ans.constant += right.number + * else: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_const); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":428 + * ans.constant += right.constant + * elif right.getOp() == Operator.const: + * ans.constant += right.number # <<<<<<<<<<<<<< + * else: + * ans.coefs.append(1.0) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_ans->constant, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_ans->constant); + __Pyx_DECREF(__pyx_v_ans->constant); + __pyx_v_ans->constant = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":427 + * ans.children.extend(right.children) + * ans.constant += right.constant + * elif right.getOp() == Operator.const: # <<<<<<<<<<<<<< + * ans.constant += right.number + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/expr.pxi":430 + * ans.constant += right.number + * else: + * ans.coefs.append(1.0) # <<<<<<<<<<<<<< + * ans.children.append(right) + * + */ + /*else*/ { + __pyx_t_7 = __Pyx_PyObject_Append(__pyx_v_ans->coefs, __pyx_float_1_0); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 430, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":431 + * else: + * ans.coefs.append(1.0) + * ans.children.append(right) # <<<<<<<<<<<<<< + * + * return ans + */ + __pyx_t_7 = __Pyx_PyObject_Append(__pyx_v_ans->__pyx_base.children, __pyx_v_right); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 431, __pyx_L1_error) + } + __pyx_L4:; + + /* "src/pyscipopt/expr.pxi":433 + * ans.children.append(right) + * + * return ans # <<<<<<<<<<<<<< + * + * #def __iadd__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_ans); + __pyx_r = ((PyObject *)__pyx_v_ans); + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":406 + * return UnaryExpr(Operator.fabs, self) + * + * def __add__(self, other): # <<<<<<<<<<<<<< + * left = buildGenExprObj(self) + * right = buildGenExprObj(other) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__add__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_left); + __Pyx_XDECREF(__pyx_v_right); + __Pyx_XDECREF((PyObject *)__pyx_v_ans); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":461 + * # return self + * + * def __mul__(self, other): # <<<<<<<<<<<<<< + * left = buildGenExprObj(self) + * right = buildGenExprObj(other) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_7__mul__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_7__mul__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__mul__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_6__mul__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_6__mul__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_left = NULL; + PyObject *__pyx_v_right = NULL; + struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_ans = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__mul__", 1); + + /* "src/pyscipopt/expr.pxi":462 + * + * def __mul__(self, other): + * left = buildGenExprObj(self) # <<<<<<<<<<<<<< + * right = buildGenExprObj(other) + * ans = ProdExpr() + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 462, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 462, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_left = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":463 + * def __mul__(self, other): + * left = buildGenExprObj(self) + * right = buildGenExprObj(other) # <<<<<<<<<<<<<< + * ans = ProdExpr() + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 463, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 463, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_right = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":464 + * left = buildGenExprObj(self) + * right = buildGenExprObj(other) + * ans = ProdExpr() # <<<<<<<<<<<<<< + * + * # multiply left factor + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ProdExpr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_ans = ((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":467 + * + * # multiply left factor + * if left.getOp() == Operator.prod: # <<<<<<<<<<<<<< + * ans.children.extend(left.children) + * ans.constant *= left.constant + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_prod); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 467, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 467, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":468 + * # multiply left factor + * if left.getOp() == Operator.prod: + * ans.children.extend(left.children) # <<<<<<<<<<<<<< + * ans.constant *= left.constant + * elif left.getOp() == Operator.const: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ans->__pyx_base.children, __pyx_n_s_extend); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_children); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":469 + * if left.getOp() == Operator.prod: + * ans.children.extend(left.children) + * ans.constant *= left.constant # <<<<<<<<<<<<<< + * elif left.getOp() == Operator.const: + * ans.constant *= left.number + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_constant); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_v_ans->constant, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_ans->constant); + __Pyx_DECREF(__pyx_v_ans->constant); + __pyx_v_ans->constant = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":467 + * + * # multiply left factor + * if left.getOp() == Operator.prod: # <<<<<<<<<<<<<< + * ans.children.extend(left.children) + * ans.constant *= left.constant + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":470 + * ans.children.extend(left.children) + * ans.constant *= left.constant + * elif left.getOp() == Operator.const: # <<<<<<<<<<<<<< + * ans.constant *= left.number + * else: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_const); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 470, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 470, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":471 + * ans.constant *= left.constant + * elif left.getOp() == Operator.const: + * ans.constant *= left.number # <<<<<<<<<<<<<< + * else: + * ans.children.append(left) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_left, __pyx_n_s_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyNumber_InPlaceMultiply(__pyx_v_ans->constant, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_ans->constant); + __Pyx_DECREF(__pyx_v_ans->constant); + __pyx_v_ans->constant = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":470 + * ans.children.extend(left.children) + * ans.constant *= left.constant + * elif left.getOp() == Operator.const: # <<<<<<<<<<<<<< + * ans.constant *= left.number + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":473 + * ans.constant *= left.number + * else: + * ans.children.append(left) # <<<<<<<<<<<<<< + * + * # multiply right factor + */ + /*else*/ { + __pyx_t_7 = __Pyx_PyObject_Append(__pyx_v_ans->__pyx_base.children, __pyx_v_left); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 473, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/expr.pxi":476 + * + * # multiply right factor + * if right.getOp() == Operator.prod: # <<<<<<<<<<<<<< + * ans.children.extend(right.children) + * ans.constant *= right.constant + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_prod); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 476, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 476, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":477 + * # multiply right factor + * if right.getOp() == Operator.prod: + * ans.children.extend(right.children) # <<<<<<<<<<<<<< + * ans.constant *= right.constant + * elif right.getOp() == Operator.const: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_ans->__pyx_base.children, __pyx_n_s_extend); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_children); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":478 + * if right.getOp() == Operator.prod: + * ans.children.extend(right.children) + * ans.constant *= right.constant # <<<<<<<<<<<<<< + * elif right.getOp() == Operator.const: + * ans.constant *= right.number + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_constant); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_v_ans->constant, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_ans->constant); + __Pyx_DECREF(__pyx_v_ans->constant); + __pyx_v_ans->constant = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":476 + * + * # multiply right factor + * if right.getOp() == Operator.prod: # <<<<<<<<<<<<<< + * ans.children.extend(right.children) + * ans.constant *= right.constant + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/expr.pxi":479 + * ans.children.extend(right.children) + * ans.constant *= right.constant + * elif right.getOp() == Operator.const: # <<<<<<<<<<<<<< + * ans.constant *= right.number + * else: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_const); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 479, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 479, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":480 + * ans.constant *= right.constant + * elif right.getOp() == Operator.const: + * ans.constant *= right.number # <<<<<<<<<<<<<< + * else: + * ans.children.append(right) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_right, __pyx_n_s_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 480, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyNumber_InPlaceMultiply(__pyx_v_ans->constant, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 480, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_ans->constant); + __Pyx_DECREF(__pyx_v_ans->constant); + __pyx_v_ans->constant = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":479 + * ans.children.extend(right.children) + * ans.constant *= right.constant + * elif right.getOp() == Operator.const: # <<<<<<<<<<<<<< + * ans.constant *= right.number + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/expr.pxi":482 + * ans.constant *= right.number + * else: + * ans.children.append(right) # <<<<<<<<<<<<<< + * + * return ans + */ + /*else*/ { + __pyx_t_7 = __Pyx_PyObject_Append(__pyx_v_ans->__pyx_base.children, __pyx_v_right); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 482, __pyx_L1_error) + } + __pyx_L4:; + + /* "src/pyscipopt/expr.pxi":484 + * ans.children.append(right) + * + * return ans # <<<<<<<<<<<<<< + * + * #def __imul__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_ans); + __pyx_r = ((PyObject *)__pyx_v_ans); + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":461 + * # return self + * + * def __mul__(self, other): # <<<<<<<<<<<<<< + * left = buildGenExprObj(self) + * right = buildGenExprObj(other) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__mul__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_left); + __Pyx_XDECREF(__pyx_v_right); + __Pyx_XDECREF((PyObject *)__pyx_v_ans); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":508 + * # return self + * + * def __pow__(self, other, modulo): # <<<<<<<<<<<<<< + * expo = buildGenExprObj(other) + * if expo.getOp() != Operator.const: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_9__pow__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_modulo); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_9__pow__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_modulo) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pow__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_8__pow__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other), ((PyObject *)__pyx_v_modulo)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_8__pow__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other, CYTHON_UNUSED PyObject *__pyx_v_modulo) { + PyObject *__pyx_v_expo = NULL; + struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_ans = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pow__", 1); + + /* "src/pyscipopt/expr.pxi":509 + * + * def __pow__(self, other, modulo): + * expo = buildGenExprObj(other) # <<<<<<<<<<<<<< + * if expo.getOp() != Operator.const: + * raise NotImplementedError("exponents must be numbers") + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_expo = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":510 + * def __pow__(self, other, modulo): + * expo = buildGenExprObj(other) + * if expo.getOp() != Operator.const: # <<<<<<<<<<<<<< + * raise NotImplementedError("exponents must be numbers") + * if self.getOp() == Operator.const: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_expo, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_const); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 510, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 510, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__pyx_t_5)) { + + /* "src/pyscipopt/expr.pxi":511 + * expo = buildGenExprObj(other) + * if expo.getOp() != Operator.const: + * raise NotImplementedError("exponents must be numbers") # <<<<<<<<<<<<<< + * if self.getOp() == Operator.const: + * return Constant(self.number**expo.number) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 511, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":510 + * def __pow__(self, other, modulo): + * expo = buildGenExprObj(other) + * if expo.getOp() != Operator.const: # <<<<<<<<<<<<<< + * raise NotImplementedError("exponents must be numbers") + * if self.getOp() == Operator.const: + */ + } + + /* "src/pyscipopt/expr.pxi":512 + * if expo.getOp() != Operator.const: + * raise NotImplementedError("exponents must be numbers") + * if self.getOp() == Operator.const: # <<<<<<<<<<<<<< + * return Constant(self.number**expo.number) + * ans = PowExpr() + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getOp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Operator); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_const); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/expr.pxi":513 + * raise NotImplementedError("exponents must be numbers") + * if self.getOp() == Operator.const: + * return Constant(self.number**expo.number) # <<<<<<<<<<<<<< + * ans = PowExpr() + * ans.children.append(self) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_number); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_expo, __pyx_n_s_number); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Power(__pyx_t_3, __pyx_t_1, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constant), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":512 + * if expo.getOp() != Operator.const: + * raise NotImplementedError("exponents must be numbers") + * if self.getOp() == Operator.const: # <<<<<<<<<<<<<< + * return Constant(self.number**expo.number) + * ans = PowExpr() + */ + } + + /* "src/pyscipopt/expr.pxi":514 + * if self.getOp() == Operator.const: + * return Constant(self.number**expo.number) + * ans = PowExpr() # <<<<<<<<<<<<<< + * ans.children.append(self) + * ans.expo = expo.number + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PowExpr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_ans = ((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":515 + * return Constant(self.number**expo.number) + * ans = PowExpr() + * ans.children.append(self) # <<<<<<<<<<<<<< + * ans.expo = expo.number + * + */ + __pyx_t_6 = __Pyx_PyObject_Append(__pyx_v_ans->__pyx_base.children, ((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 515, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":516 + * ans = PowExpr() + * ans.children.append(self) + * ans.expo = expo.number # <<<<<<<<<<<<<< + * + * return ans + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_expo, __pyx_n_s_number); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_ans->expo); + __Pyx_DECREF(__pyx_v_ans->expo); + __pyx_v_ans->expo = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":518 + * ans.expo = expo.number + * + * return ans # <<<<<<<<<<<<<< + * + * #TODO: ipow, idiv, etc + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_ans); + __pyx_r = ((PyObject *)__pyx_v_ans); + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":508 + * # return self + * + * def __pow__(self, other, modulo): # <<<<<<<<<<<<<< + * expo = buildGenExprObj(other) + * if expo.getOp() != Operator.const: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__pow__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_expo); + __Pyx_XDECREF((PyObject *)__pyx_v_ans); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":521 + * + * #TODO: ipow, idiv, etc + * def __truediv__(self,other): # <<<<<<<<<<<<<< + * divisor = buildGenExprObj(other) + * # we can't divide by 0 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_11__truediv__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_11__truediv__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__truediv__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_10__truediv__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_10__truediv__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_divisor = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__truediv__", 1); + + /* "src/pyscipopt/expr.pxi":522 + * #TODO: ipow, idiv, etc + * def __truediv__(self,other): + * divisor = buildGenExprObj(other) # <<<<<<<<<<<<<< + * # we can't divide by 0 + * if divisor.getOp() == Operator.const and divisor.number == 0.0: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_divisor = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":524 + * divisor = buildGenExprObj(other) + * # we can't divide by 0 + * if divisor.getOp() == Operator.const and divisor.number == 0.0: # <<<<<<<<<<<<<< + * raise ZeroDivisionError("cannot divide by 0") + * return self * divisor**(-1) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_divisor, __pyx_n_s_getOp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_const); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_6) { + } else { + __pyx_t_5 = __pyx_t_6; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_divisor, __pyx_n_s_number); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = (__Pyx_PyFloat_BoolEqObjC(__pyx_t_2, __pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __pyx_t_6; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_5)) { + + /* "src/pyscipopt/expr.pxi":525 + * # we can't divide by 0 + * if divisor.getOp() == Operator.const and divisor.number == 0.0: + * raise ZeroDivisionError("cannot divide by 0") # <<<<<<<<<<<<<< + * return self * divisor**(-1) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ZeroDivisionError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 525, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":524 + * divisor = buildGenExprObj(other) + * # we can't divide by 0 + * if divisor.getOp() == Operator.const and divisor.number == 0.0: # <<<<<<<<<<<<<< + * raise ZeroDivisionError("cannot divide by 0") + * return self * divisor**(-1) + */ + } + + /* "src/pyscipopt/expr.pxi":526 + * if divisor.getOp() == Operator.const and divisor.number == 0.0: + * raise ZeroDivisionError("cannot divide by 0") + * return self * divisor**(-1) # <<<<<<<<<<<<<< + * + * def __rtruediv__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyNumber_Power(__pyx_v_divisor, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(((PyObject *)__pyx_v_self), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":521 + * + * #TODO: ipow, idiv, etc + * def __truediv__(self,other): # <<<<<<<<<<<<<< + * divisor = buildGenExprObj(other) + * # we can't divide by 0 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__truediv__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_divisor); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":528 + * return self * divisor**(-1) + * + * def __rtruediv__(self, other): # <<<<<<<<<<<<<< + * ''' other / self ''' + * otherexpr = buildGenExprObj(other) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_13__rtruediv__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7GenExpr_12__rtruediv__, " other / self "); +#if CYTHON_UPDATE_DESCRIPTOR_DOC +struct wrapperbase __pyx_wrapperbase_9pyscipopt_4scip_7GenExpr_12__rtruediv__; +#endif +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_13__rtruediv__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__rtruediv__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_12__rtruediv__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_12__rtruediv__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_v_otherexpr = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__rtruediv__", 1); + + /* "src/pyscipopt/expr.pxi":530 + * def __rtruediv__(self, other): + * ''' other / self ''' + * otherexpr = buildGenExprObj(other) # <<<<<<<<<<<<<< + * return otherexpr.__truediv__(self) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 530, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 530, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_otherexpr = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":531 + * ''' other / self ''' + * otherexpr = buildGenExprObj(other) + * return otherexpr.__truediv__(self) # <<<<<<<<<<<<<< + * + * def __neg__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_otherexpr, __pyx_n_s_truediv); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":528 + * return self * divisor**(-1) + * + * def __rtruediv__(self, other): # <<<<<<<<<<<<<< + * ''' other / self ''' + * otherexpr = buildGenExprObj(other) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__rtruediv__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_otherexpr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":533 + * return otherexpr.__truediv__(self) + * + * def __neg__(self): # <<<<<<<<<<<<<< + * return -1.0 * self + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_15__neg__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_15__neg__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__neg__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_14__neg__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_14__neg__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__neg__", 1); + + /* "src/pyscipopt/expr.pxi":534 + * + * def __neg__(self): + * return -1.0 * self # <<<<<<<<<<<<<< + * + * def __sub__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Multiply(__pyx_float_neg_1_0, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":533 + * return otherexpr.__truediv__(self) + * + * def __neg__(self): # <<<<<<<<<<<<<< + * return -1.0 * self + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__neg__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":536 + * return -1.0 * self + * + * def __sub__(self, other): # <<<<<<<<<<<<<< + * return self + (-other) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_17__sub__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_17__sub__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__sub__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_16__sub__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_16__sub__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__sub__", 1); + + /* "src/pyscipopt/expr.pxi":537 + * + * def __sub__(self, other): + * return self + (-other) # <<<<<<<<<<<<<< + * + * def __radd__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Negative(__pyx_v_other); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Add(((PyObject *)__pyx_v_self), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":536 + * return -1.0 * self + * + * def __sub__(self, other): # <<<<<<<<<<<<<< + * return self + (-other) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__sub__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":539 + * return self + (-other) + * + * def __radd__(self, other): # <<<<<<<<<<<<<< + * return self.__add__(other) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_19__radd__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_19__radd__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__radd__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_18__radd__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_18__radd__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__radd__", 1); + + /* "src/pyscipopt/expr.pxi":540 + * + * def __radd__(self, other): + * return self.__add__(other) # <<<<<<<<<<<<<< + * + * def __rmul__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":539 + * return self + (-other) + * + * def __radd__(self, other): # <<<<<<<<<<<<<< + * return self.__add__(other) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__radd__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":542 + * return self.__add__(other) + * + * def __rmul__(self, other): # <<<<<<<<<<<<<< + * return self.__mul__(other) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_21__rmul__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_21__rmul__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__rmul__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_20__rmul__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_20__rmul__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__rmul__", 1); + + /* "src/pyscipopt/expr.pxi":543 + * + * def __rmul__(self, other): + * return self.__mul__(other) # <<<<<<<<<<<<<< + * + * def __rsub__(self, other): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_mul); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_other}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":542 + * return self.__add__(other) + * + * def __rmul__(self, other): # <<<<<<<<<<<<<< + * return self.__mul__(other) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__rmul__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":545 + * return self.__mul__(other) + * + * def __rsub__(self, other): # <<<<<<<<<<<<<< + * return -1.0 * self + other + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_23__rsub__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_23__rsub__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__rsub__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_22__rsub__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_22__rsub__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__rsub__", 1); + + /* "src/pyscipopt/expr.pxi":546 + * + * def __rsub__(self, other): + * return -1.0 * self + other # <<<<<<<<<<<<<< + * + * def __richcmp__(self, other, op): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Multiply(__pyx_float_neg_1_0, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_other); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":545 + * return self.__mul__(other) + * + * def __rsub__(self, other): # <<<<<<<<<<<<<< + * return -1.0 * self + other + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__rsub__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":548 + * return -1.0 * self + other + * + * def __richcmp__(self, other, op): # <<<<<<<<<<<<<< + * '''turn it into a constraint''' + * return _expr_richcmp(self, other, op) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_25__richcmp__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, int __pyx_arg_op); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_25__richcmp__(PyObject *__pyx_v_self, PyObject *__pyx_v_other, int __pyx_arg_op) { + PyObject *__pyx_v_op = 0; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__richcmp__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_v_op = __Pyx_PyInt_From_int(__pyx_arg_op); if (unlikely(!__pyx_v_op)) __PYX_ERR(1, 548, __pyx_L3_error) + __Pyx_GOTREF(__pyx_v_op); + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_24__richcmp__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_other), ((PyObject *)__pyx_v_op)); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_op); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_24__richcmp__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_other, PyObject *__pyx_v_op) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__richcmp__", 1); + + /* "src/pyscipopt/expr.pxi":550 + * def __richcmp__(self, other, op): + * '''turn it into a constraint''' + * return _expr_richcmp(self, other, op) # <<<<<<<<<<<<<< + * + * def degree(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_expr_richcmp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_3, ((PyObject *)__pyx_v_self), __pyx_v_other, __pyx_v_op}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 3+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":548 + * return -1.0 * self + other + * + * def __richcmp__(self, other, op): # <<<<<<<<<<<<<< + * '''turn it into a constraint''' + * return _expr_richcmp(self, other, op) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__richcmp__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":552 + * return _expr_richcmp(self, other, op) + * + * def degree(self): # <<<<<<<<<<<<<< + * '''Note: none of these expressions should be polynomial''' + * return float('inf') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_27degree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7GenExpr_26degree, "GenExpr.degree(self)\nNote: none of these expressions should be polynomial"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7GenExpr_27degree = {"degree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7GenExpr_27degree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7GenExpr_26degree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_27degree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("degree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("degree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "degree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_26degree(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_26degree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + double __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("degree", 1); + + /* "src/pyscipopt/expr.pxi":554 + * def degree(self): + * '''Note: none of these expressions should be polynomial''' + * return float('inf') # <<<<<<<<<<<<<< + * + * def getOp(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyUnicode_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_1 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(1, 554, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 554, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":552 + * return _expr_richcmp(self, other, op) + * + * def degree(self): # <<<<<<<<<<<<<< + * '''Note: none of these expressions should be polynomial''' + * return float('inf') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.degree", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":556 + * return float('inf') + * + * def getOp(self): # <<<<<<<<<<<<<< + * '''returns operator of GenExpr''' + * return self._op + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_29getOp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7GenExpr_28getOp, "GenExpr.getOp(self)\nreturns operator of GenExpr"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7GenExpr_29getOp = {"getOp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7GenExpr_29getOp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7GenExpr_28getOp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_29getOp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getOp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getOp", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOp", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_28getOp(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_28getOp(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getOp", 1); + + /* "src/pyscipopt/expr.pxi":558 + * def getOp(self): + * '''returns operator of GenExpr''' + * return self._op # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_op); + __pyx_r = __pyx_v_self->_op; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":556 + * return float('inf') + * + * def getOp(self): # <<<<<<<<<<<<<< + * '''returns operator of GenExpr''' + * return self._op + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":396 + * #See also the @ref ExprDetails "description" in the expr.pxi. + * cdef class GenExpr: + * cdef public _op # <<<<<<<<<<<<<< + * cdef public children + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_3_op___get__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_3_op___get__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_op); + __pyx_r = __pyx_v_self->_op; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_3_op_2__set__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7GenExpr_3_op_2__set__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->_op); + __Pyx_DECREF(__pyx_v_self->_op); + __pyx_v_self->_op = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_3_op_4__del__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7GenExpr_3_op_4__del__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_op); + __Pyx_DECREF(__pyx_v_self->_op); + __pyx_v_self->_op = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":397 + * cdef class GenExpr: + * cdef public _op + * cdef public children # <<<<<<<<<<<<<< + * + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_8children_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_8children_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_8children___get__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_8children___get__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->children); + __pyx_r = __pyx_v_self->children; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_8children_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_8children_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_8children_2__set__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7GenExpr_8children_2__set__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->children); + __Pyx_DECREF(__pyx_v_self->children); + __pyx_v_self->children = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_8children_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7GenExpr_8children_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_8children_4__del__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7GenExpr_8children_4__del__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->children); + __Pyx_DECREF(__pyx_v_self->children); + __pyx_v_self->children = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_31__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7GenExpr_30__reduce_cython__, "GenExpr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7GenExpr_31__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7GenExpr_31__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7GenExpr_30__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_31__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_30__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_30__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._op, self.children) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->_op); + __Pyx_GIVEREF(__pyx_v_self->_op); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->_op)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->children); + __Pyx_GIVEREF(__pyx_v_self->children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->children)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._op, self.children) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self._op, self.children) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._op is not None or self.children is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._op, self.children) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._op is not None or self.children is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, None), state + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->_op != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->children != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._op is not None or self.children is not None + * if use_setstate: + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_GenExpr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_214626690); + __Pyx_GIVEREF(__pyx_int_214626690); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_214626690)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, None), state + * else: + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_GenExpr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_GenExpr); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_214626690); + __Pyx_GIVEREF(__pyx_int_214626690); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_214626690)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_GenExpr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_33__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7GenExpr_32__setstate_cython__, "GenExpr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7GenExpr_33__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7GenExpr_33__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7GenExpr_32__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7GenExpr_33__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7GenExpr_32__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7GenExpr_32__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_GenExpr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_GenExpr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_GenExpr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.GenExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":567 + * cdef public coefs + * + * def __init__(self): # <<<<<<<<<<<<<< + * self.constant = 0.0 + * self.coefs = [] + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr___init__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7SumExpr___init__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":568 + * + * def __init__(self): + * self.constant = 0.0 # <<<<<<<<<<<<<< + * self.coefs = [] + * self.children = [] + */ + __Pyx_INCREF(__pyx_float_0_0); + __Pyx_GIVEREF(__pyx_float_0_0); + __Pyx_GOTREF(__pyx_v_self->constant); + __Pyx_DECREF(__pyx_v_self->constant); + __pyx_v_self->constant = __pyx_float_0_0; + + /* "src/pyscipopt/expr.pxi":569 + * def __init__(self): + * self.constant = 0.0 + * self.coefs = [] # <<<<<<<<<<<<<< + * self.children = [] + * self._op = Operator.add + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->coefs); + __Pyx_DECREF(__pyx_v_self->coefs); + __pyx_v_self->coefs = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":570 + * self.constant = 0.0 + * self.coefs = [] + * self.children = [] # <<<<<<<<<<<<<< + * self._op = Operator.add + * def __repr__(self): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->__pyx_base.children); + __Pyx_DECREF(__pyx_v_self->__pyx_base.children); + __pyx_v_self->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":571 + * self.coefs = [] + * self.children = [] + * self._op = Operator.add # <<<<<<<<<<<<<< + * def __repr__(self): + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_add_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->__pyx_base._op); + __Pyx_DECREF(__pyx_v_self->__pyx_base._op); + __pyx_v_self->__pyx_base._op = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":567 + * cdef public coefs + * + * def __init__(self): # <<<<<<<<<<<<<< + * self.constant = 0.0 + * self.coefs = [] + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.SumExpr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":572 + * self.children = [] + * self._op = Operator.add + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_2__repr__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":573 + * self._op = Operator.add + * def __repr__(self): + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" # <<<<<<<<<<<<<< + * + * # Prod Expressions + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_8__repr___lambda3(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7SumExpr_8__repr___lambda3 = {"lambda3", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7SumExpr_8__repr___lambda3, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_8__repr___lambda3(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_child = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lambda3 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_child,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_child)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 573, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "lambda3") < 0)) __PYX_ERR(1, 573, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_child = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lambda3", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 573, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.SumExpr.__repr__.lambda3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_lambda_funcdef_lambda3(__pyx_self, __pyx_v_child); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_lambda_funcdef_lambda3(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_child) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lambda3", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_child, __pyx_n_s_repr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.SumExpr.__repr__.lambda3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":572 + * self.children = [] + * self._op = Operator.add + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + * + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":573 + * self._op = Operator.add + * def __repr__(self): + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" # <<<<<<<<<<<<<< + * + * # Prod Expressions + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Add(__pyx_v_self->__pyx_base._op, __pyx_kp_u__9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Str(__pyx_v_self->constant); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_kp_u__10); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7SumExpr_8__repr___lambda3, 0, __pyx_n_s_repr___locals_lambda, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3)) __PYX_ERR(1, 573, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->__pyx_base.children); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->__pyx_base.children)) __PYX_ERR(1, 573, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_map, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyUnicode_Join(__pyx_kp_u__10, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_kp_u__6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":572 + * self.children = [] + * self._op = Operator.add + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.SumExpr.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":564 + * cdef class SumExpr(GenExpr): + * + * cdef public constant # <<<<<<<<<<<<<< + * cdef public coefs + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_8constant___get__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_8constant___get__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->constant); + __pyx_r = __pyx_v_self->constant; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_8constant_2__set__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7SumExpr_8constant_2__set__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->constant); + __Pyx_DECREF(__pyx_v_self->constant); + __pyx_v_self->constant = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_8constant_4__del__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7SumExpr_8constant_4__del__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->constant); + __Pyx_DECREF(__pyx_v_self->constant); + __pyx_v_self->constant = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":565 + * + * cdef public constant + * cdef public coefs # <<<<<<<<<<<<<< + * + * def __init__(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs___get__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs___get__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->coefs); + __pyx_r = __pyx_v_self->coefs; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs_2__set__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs_2__set__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->coefs); + __Pyx_DECREF(__pyx_v_self->coefs); + __pyx_v_self->coefs = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs_4__del__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7SumExpr_5coefs_4__del__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->coefs); + __Pyx_DECREF(__pyx_v_self->coefs); + __pyx_v_self->coefs = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7SumExpr_4__reduce_cython__, "SumExpr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7SumExpr_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7SumExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7SumExpr_4__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_4__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._op, self.children, self.coefs, self.constant) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->__pyx_base._op); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base._op); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->__pyx_base._op)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->__pyx_base.children); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->__pyx_base.children)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->coefs); + __Pyx_GIVEREF(__pyx_v_self->coefs); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->coefs)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->constant); + __Pyx_GIVEREF(__pyx_v_self->constant); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_self->constant)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._op, self.children, self.coefs, self.constant) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.coefs, self.constant) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._op is not None or self.children is not None or self.coefs is not None or self.constant is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.coefs, self.constant) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._op is not None or self.children is not None or self.coefs is not None or self.constant is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, None), state + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->__pyx_base._op != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->__pyx_base.children != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->coefs != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->constant != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.coefs is not None or self.constant is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._op is not None or self.children is not None or self.coefs is not None or self.constant is not None + * if use_setstate: + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_SumExpr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_63254455); + __Pyx_GIVEREF(__pyx_int_63254455); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_63254455)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.coefs is not None or self.constant is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, None), state + * else: + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_SumExpr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_SumExpr); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_63254455); + __Pyx_GIVEREF(__pyx_int_63254455); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_63254455)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.SumExpr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_SumExpr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7SumExpr_6__setstate_cython__, "SumExpr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7SumExpr_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7SumExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7SumExpr_6__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7SumExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.SumExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7SumExpr_6__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7SumExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_SumExpr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_SumExpr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_SumExpr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.SumExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":578 + * cdef class ProdExpr(GenExpr): + * cdef public constant + * def __init__(self): # <<<<<<<<<<<<<< + * self.constant = 1.0 + * self.children = [] + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ProdExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ProdExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ProdExpr___init__(((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ProdExpr___init__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":579 + * cdef public constant + * def __init__(self): + * self.constant = 1.0 # <<<<<<<<<<<<<< + * self.children = [] + * self._op = Operator.prod + */ + __Pyx_INCREF(__pyx_float_1_0); + __Pyx_GIVEREF(__pyx_float_1_0); + __Pyx_GOTREF(__pyx_v_self->constant); + __Pyx_DECREF(__pyx_v_self->constant); + __pyx_v_self->constant = __pyx_float_1_0; + + /* "src/pyscipopt/expr.pxi":580 + * def __init__(self): + * self.constant = 1.0 + * self.children = [] # <<<<<<<<<<<<<< + * self._op = Operator.prod + * def __repr__(self): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->__pyx_base.children); + __Pyx_DECREF(__pyx_v_self->__pyx_base.children); + __pyx_v_self->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":581 + * self.constant = 1.0 + * self.children = [] + * self._op = Operator.prod # <<<<<<<<<<<<<< + * def __repr__(self): + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_prod); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->__pyx_base._op); + __Pyx_DECREF(__pyx_v_self->__pyx_base._op); + __pyx_v_self->__pyx_base._op = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":578 + * cdef class ProdExpr(GenExpr): + * cdef public constant + * def __init__(self): # <<<<<<<<<<<<<< + * self.constant = 1.0 + * self.children = [] + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.ProdExpr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":582 + * self.children = [] + * self._op = Operator.prod + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ProdExpr_2__repr__(((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":583 + * self._op = Operator.prod + * def __repr__(self): + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" # <<<<<<<<<<<<<< + * + * # Var Expressions + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_8__repr___lambda4(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8ProdExpr_8__repr___lambda4 = {"lambda4", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ProdExpr_8__repr___lambda4, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_8__repr___lambda4(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_child = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lambda4 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_child,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_child)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 583, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "lambda4") < 0)) __PYX_ERR(1, 583, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_child = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lambda4", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 583, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.ProdExpr.__repr__.lambda4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_lambda_funcdef_lambda4(__pyx_self, __pyx_v_child); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_lambda_funcdef_lambda4(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_child) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lambda4", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_child, __pyx_n_s_repr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.ProdExpr.__repr__.lambda4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":582 + * self.children = [] + * self._op = Operator.prod + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + * + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ProdExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":583 + * self._op = Operator.prod + * def __repr__(self): + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" # <<<<<<<<<<<<<< + * + * # Var Expressions + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Add(__pyx_v_self->__pyx_base._op, __pyx_kp_u__9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Str(__pyx_v_self->constant); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_kp_u__10); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8ProdExpr_8__repr___lambda4, 0, __pyx_n_s_repr___locals_lambda, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3)) __PYX_ERR(1, 583, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->__pyx_base.children); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->__pyx_base.children)) __PYX_ERR(1, 583, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_map, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyUnicode_Join(__pyx_kp_u__10, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_kp_u__6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":582 + * self.children = [] + * self._op = Operator.prod + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + str(self.constant) + "," + ",".join(map(lambda child : child.__repr__(), self.children)) + ")" + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.ProdExpr.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":577 + * # Prod Expressions + * cdef class ProdExpr(GenExpr): + * cdef public constant # <<<<<<<<<<<<<< + * def __init__(self): + * self.constant = 1.0 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant___get__(((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant___get__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->constant); + __pyx_r = __pyx_v_self->constant; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant_2__set__(((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant_2__set__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->constant); + __Pyx_DECREF(__pyx_v_self->constant); + __pyx_v_self->constant = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant_4__del__(((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8ProdExpr_8constant_4__del__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->constant); + __Pyx_DECREF(__pyx_v_self->constant); + __pyx_v_self->constant = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8ProdExpr_4__reduce_cython__, "ProdExpr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8ProdExpr_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ProdExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ProdExpr_4__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ProdExpr_4__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ProdExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._op, self.children, self.constant) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->__pyx_base._op); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base._op); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->__pyx_base._op)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->__pyx_base.children); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->__pyx_base.children)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->constant); + __Pyx_GIVEREF(__pyx_v_self->constant); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->constant)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._op, self.children, self.constant) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.constant) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._op is not None or self.children is not None or self.constant is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.constant) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._op is not None or self.children is not None or self.constant is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, None), state + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->__pyx_base._op != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->__pyx_base.children != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->constant != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.constant is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._op is not None or self.children is not None or self.constant is not None + * if use_setstate: + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_ProdExpr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_240430858); + __Pyx_GIVEREF(__pyx_int_240430858); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_240430858)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.constant is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, None), state + * else: + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_ProdExpr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_ProdExpr); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_240430858); + __Pyx_GIVEREF(__pyx_int_240430858); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_240430858)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.ProdExpr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ProdExpr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8ProdExpr_6__setstate_cython__, "ProdExpr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8ProdExpr_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ProdExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ProdExpr_6__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8ProdExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.ProdExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8ProdExpr_6__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8ProdExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_ProdExpr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_ProdExpr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ProdExpr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.ProdExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":588 + * cdef class VarExpr(GenExpr): + * cdef public var + * def __init__(self, var): # <<<<<<<<<<<<<< + * self.children = [var] + * self._op = Operator.varidx + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7VarExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7VarExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_var = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 588, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 588, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + } + __pyx_v_var = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 588, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.VarExpr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7VarExpr___init__(((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_v_self), __pyx_v_var); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7VarExpr___init__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self, PyObject *__pyx_v_var) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":589 + * cdef public var + * def __init__(self, var): + * self.children = [var] # <<<<<<<<<<<<<< + * self._op = Operator.varidx + * def __repr__(self): + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_var); + __Pyx_GIVEREF(__pyx_v_var); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_var)) __PYX_ERR(1, 589, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->__pyx_base.children); + __Pyx_DECREF(__pyx_v_self->__pyx_base.children); + __pyx_v_self->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":590 + * def __init__(self, var): + * self.children = [var] + * self._op = Operator.varidx # <<<<<<<<<<<<<< + * def __repr__(self): + * return self.children[0].__repr__() + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_varidx); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->__pyx_base._op); + __Pyx_DECREF(__pyx_v_self->__pyx_base._op); + __pyx_v_self->__pyx_base._op = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":588 + * cdef class VarExpr(GenExpr): + * cdef public var + * def __init__(self, var): # <<<<<<<<<<<<<< + * self.children = [var] + * self._op = Operator.varidx + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.VarExpr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":591 + * self.children = [var] + * self._op = Operator.varidx + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.children[0].__repr__() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7VarExpr_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7VarExpr_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7VarExpr_2__repr__(((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7VarExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":592 + * self._op = Operator.varidx + * def __repr__(self): + * return self.children[0].__repr__() # <<<<<<<<<<<<<< + * + * # Pow Expressions + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_self->__pyx_base.children, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_repr); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":591 + * self.children = [var] + * self._op = Operator.varidx + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.children[0].__repr__() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.VarExpr.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":587 + * # Var Expressions + * cdef class VarExpr(GenExpr): + * cdef public var # <<<<<<<<<<<<<< + * def __init__(self, var): + * self.children = [var] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7VarExpr_3var_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7VarExpr_3var_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7VarExpr_3var___get__(((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7VarExpr_3var___get__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->var); + __pyx_r = __pyx_v_self->var; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7VarExpr_3var_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7VarExpr_3var_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7VarExpr_3var_2__set__(((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7VarExpr_3var_2__set__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->var); + __Pyx_DECREF(__pyx_v_self->var); + __pyx_v_self->var = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7VarExpr_3var_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7VarExpr_3var_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7VarExpr_3var_4__del__(((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7VarExpr_3var_4__del__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->var); + __Pyx_DECREF(__pyx_v_self->var); + __pyx_v_self->var = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7VarExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7VarExpr_4__reduce_cython__, "VarExpr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7VarExpr_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7VarExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7VarExpr_4__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7VarExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7VarExpr_4__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7VarExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._op, self.children, self.var) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->__pyx_base._op); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base._op); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->__pyx_base._op)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->__pyx_base.children); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->__pyx_base.children)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->var); + __Pyx_GIVEREF(__pyx_v_self->var); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->var)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._op, self.children, self.var) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.var) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._op is not None or self.children is not None or self.var is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.var) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._op is not None or self.children is not None or self.var is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, None), state + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->__pyx_base._op != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->__pyx_base.children != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->var != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.var is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._op is not None or self.children is not None or self.var is not None + * if use_setstate: + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_VarExpr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76998962); + __Pyx_GIVEREF(__pyx_int_76998962); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76998962)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.var is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, None), state + * else: + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_VarExpr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_VarExpr); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76998962); + __Pyx_GIVEREF(__pyx_int_76998962); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76998962)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.VarExpr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_VarExpr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7VarExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7VarExpr_6__setstate_cython__, "VarExpr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7VarExpr_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7VarExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7VarExpr_6__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7VarExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.VarExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7VarExpr_6__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7VarExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_VarExpr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_VarExpr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_VarExpr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.VarExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":597 + * cdef class PowExpr(GenExpr): + * cdef public expo + * def __init__(self): # <<<<<<<<<<<<<< + * self.expo = 1.0 + * self.children = [] + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7PowExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7PowExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7PowExpr___init__(((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7PowExpr___init__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":598 + * cdef public expo + * def __init__(self): + * self.expo = 1.0 # <<<<<<<<<<<<<< + * self.children = [] + * self._op = Operator.power + */ + __Pyx_INCREF(__pyx_float_1_0); + __Pyx_GIVEREF(__pyx_float_1_0); + __Pyx_GOTREF(__pyx_v_self->expo); + __Pyx_DECREF(__pyx_v_self->expo); + __pyx_v_self->expo = __pyx_float_1_0; + + /* "src/pyscipopt/expr.pxi":599 + * def __init__(self): + * self.expo = 1.0 + * self.children = [] # <<<<<<<<<<<<<< + * self._op = Operator.power + * def __repr__(self): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->__pyx_base.children); + __Pyx_DECREF(__pyx_v_self->__pyx_base.children); + __pyx_v_self->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":600 + * self.expo = 1.0 + * self.children = [] + * self._op = Operator.power # <<<<<<<<<<<<<< + * def __repr__(self): + * return self._op + "(" + self.children[0].__repr__() + "," + str(self.expo) + ")" + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->__pyx_base._op); + __Pyx_DECREF(__pyx_v_self->__pyx_base._op); + __pyx_v_self->__pyx_base._op = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":597 + * cdef class PowExpr(GenExpr): + * cdef public expo + * def __init__(self): # <<<<<<<<<<<<<< + * self.expo = 1.0 + * self.children = [] + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.PowExpr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":601 + * self.children = [] + * self._op = Operator.power + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + self.children[0].__repr__() + "," + str(self.expo) + ")" + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7PowExpr_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7PowExpr_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7PowExpr_2__repr__(((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7PowExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":602 + * self._op = Operator.power + * def __repr__(self): + * return self._op + "(" + self.children[0].__repr__() + "," + str(self.expo) + ")" # <<<<<<<<<<<<<< + * + * # Exp, Log, Sqrt, Sin, Cos Expressions + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Add(__pyx_v_self->__pyx_base._op, __pyx_kp_u__9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_self->__pyx_base.children, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_repr); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_kp_u__10); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Str(__pyx_v_self->expo); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_kp_u__6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":601 + * self.children = [] + * self._op = Operator.power + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + self.children[0].__repr__() + "," + str(self.expo) + ")" + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PowExpr.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":596 + * # Pow Expressions + * cdef class PowExpr(GenExpr): + * cdef public expo # <<<<<<<<<<<<<< + * def __init__(self): + * self.expo = 1.0 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7PowExpr_4expo___get__(((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7PowExpr_4expo___get__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->expo); + __pyx_r = __pyx_v_self->expo; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7PowExpr_4expo_2__set__(((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7PowExpr_4expo_2__set__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->expo); + __Pyx_DECREF(__pyx_v_self->expo); + __pyx_v_self->expo = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7PowExpr_4expo_4__del__(((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7PowExpr_4expo_4__del__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->expo); + __Pyx_DECREF(__pyx_v_self->expo); + __pyx_v_self->expo = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7PowExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7PowExpr_4__reduce_cython__, "PowExpr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7PowExpr_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7PowExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7PowExpr_4__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7PowExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7PowExpr_4__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7PowExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._op, self.children, self.expo) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->__pyx_base._op); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base._op); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->__pyx_base._op)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->__pyx_base.children); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->__pyx_base.children)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->expo); + __Pyx_GIVEREF(__pyx_v_self->expo); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->expo)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._op, self.children, self.expo) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.expo) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._op is not None or self.children is not None or self.expo is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.expo) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._op is not None or self.children is not None or self.expo is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, None), state + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->__pyx_base._op != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->__pyx_base.children != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->expo != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.expo is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._op is not None or self.children is not None or self.expo is not None + * if use_setstate: + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PowExpr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_80720285); + __Pyx_GIVEREF(__pyx_int_80720285); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_80720285)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.expo is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, None), state + * else: + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PowExpr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_PowExpr); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_80720285); + __Pyx_GIVEREF(__pyx_int_80720285); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_80720285)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.PowExpr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PowExpr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7PowExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7PowExpr_6__setstate_cython__, "PowExpr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7PowExpr_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7PowExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7PowExpr_6__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7PowExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PowExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7PowExpr_6__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7PowExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PowExpr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PowExpr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PowExpr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PowExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":606 + * # Exp, Log, Sqrt, Sin, Cos Expressions + * cdef class UnaryExpr(GenExpr): + * def __init__(self, op, expr): # <<<<<<<<<<<<<< + * self.children = [] + * self.children.append(expr) + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_9UnaryExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_9UnaryExpr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_op = 0; + PyObject *__pyx_v_expr = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_op,&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_op)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 606, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 606, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(1, 606, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 606, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + } + __pyx_v_op = values[0]; + __pyx_v_expr = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 606, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.UnaryExpr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9UnaryExpr___init__(((struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *)__pyx_v_self), __pyx_v_op, __pyx_v_expr); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_9UnaryExpr___init__(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v_self, PyObject *__pyx_v_op, PyObject *__pyx_v_expr) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":607 + * cdef class UnaryExpr(GenExpr): + * def __init__(self, op, expr): + * self.children = [] # <<<<<<<<<<<<<< + * self.children.append(expr) + * self._op = op + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->__pyx_base.children); + __Pyx_DECREF(__pyx_v_self->__pyx_base.children); + __pyx_v_self->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":608 + * def __init__(self, op, expr): + * self.children = [] + * self.children.append(expr) # <<<<<<<<<<<<<< + * self._op = op + * def __repr__(self): + */ + __pyx_t_2 = __Pyx_PyObject_Append(__pyx_v_self->__pyx_base.children, __pyx_v_expr); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 608, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":609 + * self.children = [] + * self.children.append(expr) + * self._op = op # <<<<<<<<<<<<<< + * def __repr__(self): + * return self._op + "(" + self.children[0].__repr__() + ")" + */ + __Pyx_INCREF(__pyx_v_op); + __Pyx_GIVEREF(__pyx_v_op); + __Pyx_GOTREF(__pyx_v_self->__pyx_base._op); + __Pyx_DECREF(__pyx_v_self->__pyx_base._op); + __pyx_v_self->__pyx_base._op = __pyx_v_op; + + /* "src/pyscipopt/expr.pxi":606 + * # Exp, Log, Sqrt, Sin, Cos Expressions + * cdef class UnaryExpr(GenExpr): + * def __init__(self, op, expr): # <<<<<<<<<<<<<< + * self.children = [] + * self.children.append(expr) + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.UnaryExpr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":610 + * self.children.append(expr) + * self._op = op + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + self.children[0].__repr__() + ")" + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9UnaryExpr_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_9UnaryExpr_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_9UnaryExpr_2__repr__(((struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9UnaryExpr_2__repr__(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":611 + * self._op = op + * def __repr__(self): + * return self._op + "(" + self.children[0].__repr__() + ")" # <<<<<<<<<<<<<< + * + * # class for constant expressions + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyNumber_Add(__pyx_v_self->__pyx_base._op, __pyx_kp_u__9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_self->__pyx_base.children, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_repr); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_kp_u__6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":610 + * self.children.append(expr) + * self._op = op + * def __repr__(self): # <<<<<<<<<<<<<< + * return self._op + "(" + self.children[0].__repr__() + ")" + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.UnaryExpr.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9UnaryExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9UnaryExpr_4__reduce_cython__, "UnaryExpr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9UnaryExpr_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9UnaryExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9UnaryExpr_4__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9UnaryExpr_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9UnaryExpr_4__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9UnaryExpr_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._op, self.children) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->__pyx_base._op); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base._op); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->__pyx_base._op)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->__pyx_base.children); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->__pyx_base.children)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._op, self.children) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self._op, self.children) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._op is not None or self.children is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._op, self.children) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._op is not None or self.children is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, None), state + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->__pyx_base._op != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->__pyx_base.children != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._op is not None or self.children is not None + * if use_setstate: + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_UnaryExpr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_214626690); + __Pyx_GIVEREF(__pyx_int_214626690); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_214626690)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, None), state + * else: + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_UnaryExpr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_UnaryExpr); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_214626690); + __Pyx_GIVEREF(__pyx_int_214626690); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_214626690)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.UnaryExpr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_UnaryExpr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9UnaryExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9UnaryExpr_6__setstate_cython__, "UnaryExpr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9UnaryExpr_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9UnaryExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9UnaryExpr_6__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9UnaryExpr_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.UnaryExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9UnaryExpr_6__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9UnaryExpr_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_UnaryExpr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_UnaryExpr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_UnaryExpr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.UnaryExpr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":616 + * cdef class Constant(GenExpr): + * cdef public number + * def __init__(self,number): # <<<<<<<<<<<<<< + * self.number = number + * self._op = Operator.const + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Constant_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Constant_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_number = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_number,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_number)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 616, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(1, 616, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + } + __pyx_v_number = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 616, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Constant.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Constant___init__(((struct __pyx_obj_9pyscipopt_4scip_Constant *)__pyx_v_self), __pyx_v_number); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Constant___init__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self, PyObject *__pyx_v_number) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/expr.pxi":617 + * cdef public number + * def __init__(self,number): + * self.number = number # <<<<<<<<<<<<<< + * self._op = Operator.const + * + */ + __Pyx_INCREF(__pyx_v_number); + __Pyx_GIVEREF(__pyx_v_number); + __Pyx_GOTREF(__pyx_v_self->number); + __Pyx_DECREF(__pyx_v_self->number); + __pyx_v_self->number = __pyx_v_number; + + /* "src/pyscipopt/expr.pxi":618 + * def __init__(self,number): + * self.number = number + * self._op = Operator.const # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_const); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->__pyx_base._op); + __Pyx_DECREF(__pyx_v_self->__pyx_base._op); + __pyx_v_self->__pyx_base._op = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":616 + * cdef class Constant(GenExpr): + * cdef public number + * def __init__(self,number): # <<<<<<<<<<<<<< + * self.number = number + * self._op = Operator.const + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Constant.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":620 + * self._op = Operator.const + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return str(self.number) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Constant_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Constant_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Constant_2__repr__(((struct __pyx_obj_9pyscipopt_4scip_Constant *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Constant_2__repr__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/expr.pxi":621 + * + * def __repr__(self): + * return str(self.number) # <<<<<<<<<<<<<< + * + * def exp(expr): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_Str(__pyx_v_self->number); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":620 + * self._op = Operator.const + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return str(self.number) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constant.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":615 + * # class for constant expressions + * cdef class Constant(GenExpr): + * cdef public number # <<<<<<<<<<<<<< + * def __init__(self,number): + * self.number = number + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Constant_6number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Constant_6number_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Constant_6number___get__(((struct __pyx_obj_9pyscipopt_4scip_Constant *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Constant_6number___get__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->number); + __pyx_r = __pyx_v_self->number; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Constant_6number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Constant_6number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Constant_6number_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Constant *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Constant_6number_2__set__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->number); + __Pyx_DECREF(__pyx_v_self->number); + __pyx_v_self->number = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Constant_6number_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Constant_6number_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Constant_6number_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Constant *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Constant_6number_4__del__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->number); + __Pyx_DECREF(__pyx_v_self->number); + __pyx_v_self->number = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Constant_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Constant_4__reduce_cython__, "Constant.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Constant_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Constant_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Constant_4__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Constant_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Constant_4__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Constant *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Constant_4__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self._op, self.children, self.number) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->__pyx_base._op); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base._op); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->__pyx_base._op)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->__pyx_base.children); + __Pyx_GIVEREF(__pyx_v_self->__pyx_base.children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->__pyx_base.children)) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->number); + __Pyx_GIVEREF(__pyx_v_self->number); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->number)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._op, self.children, self.number) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.number) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._op is not None or self.children is not None or self.number is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._op, self.children, self.number) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._op is not None or self.children is not None or self.number is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, None), state + */ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->__pyx_base._op != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->__pyx_base.children != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->number != Py_None); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.number is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._op is not None or self.children is not None or self.number is not None + * if use_setstate: + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Constant); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_132603380); + __Pyx_GIVEREF(__pyx_int_132603380); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_132603380)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._op is not None or self.children is not None or self.number is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, None), state + * else: + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Constant__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Constant); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_132603380); + __Pyx_GIVEREF(__pyx_int_132603380); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_132603380)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Constant.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Constant__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Constant_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Constant_6__setstate_cython__, "Constant.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Constant_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Constant_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Constant_6__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Constant_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Constant.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Constant_6__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Constant *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Constant_6__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Constant__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Constant__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Constant__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constant.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":623 + * return str(self.number) + * + * def exp(expr): # <<<<<<<<<<<<<< + * """returns expression with exp-function""" + * return UnaryExpr(Operator.exp, buildGenExprObj(expr)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11exp(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10exp, "exp(expr)\nreturns expression with exp-function"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_11exp = {"exp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11exp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10exp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_11exp(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("exp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 623, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "exp") < 0)) __PYX_ERR(1, 623, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_expr = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("exp", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 623, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.exp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10exp(__pyx_self, __pyx_v_expr); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10exp(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("exp", 1); + + /* "src/pyscipopt/expr.pxi":625 + * def exp(expr): + * """returns expression with exp-function""" + * return UnaryExpr(Operator.exp, buildGenExprObj(expr)) # <<<<<<<<<<<<<< + * def log(expr): + * """returns expression with log-function""" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_exp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_expr}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 625, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 625, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr), __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":623 + * return str(self.number) + * + * def exp(expr): # <<<<<<<<<<<<<< + * """returns expression with exp-function""" + * return UnaryExpr(Operator.exp, buildGenExprObj(expr)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.exp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":626 + * """returns expression with exp-function""" + * return UnaryExpr(Operator.exp, buildGenExprObj(expr)) + * def log(expr): # <<<<<<<<<<<<<< + * """returns expression with log-function""" + * return UnaryExpr(Operator.log, buildGenExprObj(expr)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_13log(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_12log, "log(expr)\nreturns expression with log-function"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_13log = {"log", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13log, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_12log}; +static PyObject *__pyx_pw_9pyscipopt_4scip_13log(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("log (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 626, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "log") < 0)) __PYX_ERR(1, 626, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_expr = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("log", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 626, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.log", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_12log(__pyx_self, __pyx_v_expr); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_12log(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("log", 1); + + /* "src/pyscipopt/expr.pxi":628 + * def log(expr): + * """returns expression with log-function""" + * return UnaryExpr(Operator.log, buildGenExprObj(expr)) # <<<<<<<<<<<<<< + * def sqrt(expr): + * """returns expression with sqrt-function""" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_expr}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 628, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 628, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr), __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":626 + * """returns expression with exp-function""" + * return UnaryExpr(Operator.exp, buildGenExprObj(expr)) + * def log(expr): # <<<<<<<<<<<<<< + * """returns expression with log-function""" + * return UnaryExpr(Operator.log, buildGenExprObj(expr)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.log", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":629 + * """returns expression with log-function""" + * return UnaryExpr(Operator.log, buildGenExprObj(expr)) + * def sqrt(expr): # <<<<<<<<<<<<<< + * """returns expression with sqrt-function""" + * return UnaryExpr(Operator.sqrt, buildGenExprObj(expr)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_15sqrt(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_14sqrt, "sqrt(expr)\nreturns expression with sqrt-function"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_15sqrt = {"sqrt", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_15sqrt, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14sqrt}; +static PyObject *__pyx_pw_9pyscipopt_4scip_15sqrt(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sqrt (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 629, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "sqrt") < 0)) __PYX_ERR(1, 629, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_expr = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("sqrt", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 629, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_14sqrt(__pyx_self, __pyx_v_expr); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_14sqrt(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("sqrt", 1); + + /* "src/pyscipopt/expr.pxi":631 + * def sqrt(expr): + * """returns expression with sqrt-function""" + * return UnaryExpr(Operator.sqrt, buildGenExprObj(expr)) # <<<<<<<<<<<<<< + * def sin(expr): + * """returns expression with sin-function""" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_expr}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 631, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr), __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":629 + * """returns expression with log-function""" + * return UnaryExpr(Operator.log, buildGenExprObj(expr)) + * def sqrt(expr): # <<<<<<<<<<<<<< + * """returns expression with sqrt-function""" + * return UnaryExpr(Operator.sqrt, buildGenExprObj(expr)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":632 + * """returns expression with sqrt-function""" + * return UnaryExpr(Operator.sqrt, buildGenExprObj(expr)) + * def sin(expr): # <<<<<<<<<<<<<< + * """returns expression with sin-function""" + * return UnaryExpr(Operator.sin, buildGenExprObj(expr)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_17sin(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_16sin, "sin(expr)\nreturns expression with sin-function"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_17sin = {"sin", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17sin, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_16sin}; +static PyObject *__pyx_pw_9pyscipopt_4scip_17sin(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sin (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 632, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "sin") < 0)) __PYX_ERR(1, 632, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_expr = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("sin", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 632, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.sin", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_16sin(__pyx_self, __pyx_v_expr); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_16sin(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("sin", 1); + + /* "src/pyscipopt/expr.pxi":634 + * def sin(expr): + * """returns expression with sin-function""" + * return UnaryExpr(Operator.sin, buildGenExprObj(expr)) # <<<<<<<<<<<<<< + * def cos(expr): + * """returns expression with cos-function""" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_sin); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_expr}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 634, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 634, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr), __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":632 + * """returns expression with sqrt-function""" + * return UnaryExpr(Operator.sqrt, buildGenExprObj(expr)) + * def sin(expr): # <<<<<<<<<<<<<< + * """returns expression with sin-function""" + * return UnaryExpr(Operator.sin, buildGenExprObj(expr)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.sin", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":635 + * """returns expression with sin-function""" + * return UnaryExpr(Operator.sin, buildGenExprObj(expr)) + * def cos(expr): # <<<<<<<<<<<<<< + * """returns expression with cos-function""" + * return UnaryExpr(Operator.cos, buildGenExprObj(expr)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_19cos(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_18cos, "cos(expr)\nreturns expression with cos-function"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_19cos = {"cos", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_19cos, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18cos}; +static PyObject *__pyx_pw_9pyscipopt_4scip_19cos(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cos (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 635, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "cos") < 0)) __PYX_ERR(1, 635, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_expr = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("cos", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 635, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.cos", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_18cos(__pyx_self, __pyx_v_expr); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_18cos(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("cos", 1); + + /* "src/pyscipopt/expr.pxi":637 + * def cos(expr): + * """returns expression with cos-function""" + * return UnaryExpr(Operator.cos, buildGenExprObj(expr)) # <<<<<<<<<<<<<< + * + * def expr_to_nodes(expr): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_cos); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_buildGenExprObj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_expr}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2)) __PYX_ERR(1, 637, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(1, 637, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr), __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":635 + * """returns expression with sin-function""" + * return UnaryExpr(Operator.sin, buildGenExprObj(expr)) + * def cos(expr): # <<<<<<<<<<<<<< + * """returns expression with cos-function""" + * return UnaryExpr(Operator.cos, buildGenExprObj(expr)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.cos", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":639 + * return UnaryExpr(Operator.cos, buildGenExprObj(expr)) + * + * def expr_to_nodes(expr): # <<<<<<<<<<<<<< + * '''transforms tree to an array of nodes. each node is an operator and the position of the + * children of that operator (i.e. the other nodes) in the array''' + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_21expr_to_nodes(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_20expr_to_nodes, "expr_to_nodes(expr)\ntransforms tree to an array of nodes. each node is an operator and the position of the \n children of that operator (i.e. the other nodes) in the array"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_21expr_to_nodes = {"expr_to_nodes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21expr_to_nodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20expr_to_nodes}; +static PyObject *__pyx_pw_9pyscipopt_4scip_21expr_to_nodes(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("expr_to_nodes (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 639, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "expr_to_nodes") < 0)) __PYX_ERR(1, 639, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_expr = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("expr_to_nodes", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 639, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.expr_to_nodes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_20expr_to_nodes(__pyx_self, __pyx_v_expr); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_20expr_to_nodes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr) { + PyObject *__pyx_v_nodes = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("expr_to_nodes", 1); + + /* "src/pyscipopt/expr.pxi":642 + * '''transforms tree to an array of nodes. each node is an operator and the position of the + * children of that operator (i.e. the other nodes) in the array''' + * assert isinstance(expr, GenExpr) # <<<<<<<<<<<<<< + * nodes = [] + * expr_to_array(expr, nodes) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_expr, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(1, 642, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 642, __pyx_L1_error) + #endif + + /* "src/pyscipopt/expr.pxi":643 + * children of that operator (i.e. the other nodes) in the array''' + * assert isinstance(expr, GenExpr) + * nodes = [] # <<<<<<<<<<<<<< + * expr_to_array(expr, nodes) + * return nodes + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_nodes = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":644 + * assert isinstance(expr, GenExpr) + * nodes = [] + * expr_to_array(expr, nodes) # <<<<<<<<<<<<<< + * return nodes + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_expr_to_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_expr, __pyx_v_nodes}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":645 + * nodes = [] + * expr_to_array(expr, nodes) + * return nodes # <<<<<<<<<<<<<< + * + * def value_to_array(val, nodes): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_nodes); + __pyx_r = __pyx_v_nodes; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":639 + * return UnaryExpr(Operator.cos, buildGenExprObj(expr)) + * + * def expr_to_nodes(expr): # <<<<<<<<<<<<<< + * '''transforms tree to an array of nodes. each node is an operator and the position of the + * children of that operator (i.e. the other nodes) in the array''' + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.expr_to_nodes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nodes); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":647 + * return nodes + * + * def value_to_array(val, nodes): # <<<<<<<<<<<<<< + * """adds a given value to an array""" + * nodes.append(tuple(['const', [val]])) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_23value_to_array(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_22value_to_array, "value_to_array(val, nodes)\nadds a given value to an array"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_23value_to_array = {"value_to_array", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_23value_to_array, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_22value_to_array}; +static PyObject *__pyx_pw_9pyscipopt_4scip_23value_to_array(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_val = 0; + PyObject *__pyx_v_nodes = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("value_to_array (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_val,&__pyx_n_s_nodes,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 647, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nodes)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 647, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("value_to_array", 1, 2, 2, 1); __PYX_ERR(1, 647, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "value_to_array") < 0)) __PYX_ERR(1, 647, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_val = values[0]; + __pyx_v_nodes = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("value_to_array", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 647, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.value_to_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_22value_to_array(__pyx_self, __pyx_v_val, __pyx_v_nodes); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_22value_to_array(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_val, PyObject *__pyx_v_nodes) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("value_to_array", 1); + + /* "src/pyscipopt/expr.pxi":649 + * def value_to_array(val, nodes): + * """adds a given value to an array""" + * nodes.append(tuple(['const', [val]])) # <<<<<<<<<<<<<< + * return len(nodes) - 1 + * + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_val); + __Pyx_GIVEREF(__pyx_v_val); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_val)) __PYX_ERR(1, 649, __pyx_L1_error); + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_u_const); + __Pyx_GIVEREF(__pyx_n_u_const); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_u_const)) __PYX_ERR(1, 649, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(1, 649, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_1 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Append(__pyx_v_nodes, __pyx_t_1); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 649, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":650 + * """adds a given value to an array""" + * nodes.append(tuple(['const', [val]])) + * return len(nodes) - 1 # <<<<<<<<<<<<<< + * + * # there many hacky things here: value_to_array is trying to mimick + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = PyObject_Length(__pyx_v_nodes); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(1, 650, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t((__pyx_t_4 - 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 650, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":647 + * return nodes + * + * def value_to_array(val, nodes): # <<<<<<<<<<<<<< + * """adds a given value to an array""" + * nodes.append(tuple(['const', [val]])) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.value_to_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/expr.pxi":657 + * # also, for sums, we are not considering coefficients, because basically all coefficients are 1 + * # haven't even consider substractions, but I guess we would interpret them as a - b = a + (-1) * b + * def expr_to_array(expr, nodes): # <<<<<<<<<<<<<< + * """adds expression to array""" + * op = expr._op + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_25expr_to_array(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_24expr_to_array, "expr_to_array(expr, nodes)\nadds expression to array"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_25expr_to_array = {"expr_to_array", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_25expr_to_array, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_24expr_to_array}; +static PyObject *__pyx_pw_9pyscipopt_4scip_25expr_to_array(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + PyObject *__pyx_v_nodes = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("expr_to_array (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,&__pyx_n_s_nodes,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 657, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nodes)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 657, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("expr_to_array", 1, 2, 2, 1); __PYX_ERR(1, 657, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "expr_to_array") < 0)) __PYX_ERR(1, 657, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_expr = values[0]; + __pyx_v_nodes = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("expr_to_array", 1, 2, 2, __pyx_nargs); __PYX_ERR(1, 657, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.expr_to_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_24expr_to_array(__pyx_self, __pyx_v_expr, __pyx_v_nodes); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_24expr_to_array(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_expr, PyObject *__pyx_v_nodes) { + PyObject *__pyx_v_op = NULL; + PyObject *__pyx_v_indices = NULL; + CYTHON_UNUSED Py_ssize_t __pyx_v_nchildren; + PyObject *__pyx_v_child = NULL; + PyObject *__pyx_v_pos = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("expr_to_array", 1); + + /* "src/pyscipopt/expr.pxi":659 + * def expr_to_array(expr, nodes): + * """adds expression to array""" + * op = expr._op # <<<<<<<<<<<<<< + * if op == Operator.const: # FIXME: constant expr should also have children! + * nodes.append(tuple([op, [expr.number]])) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_op_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_op = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":660 + * """adds expression to array""" + * op = expr._op + * if op == Operator.const: # FIXME: constant expr should also have children! # <<<<<<<<<<<<<< + * nodes.append(tuple([op, [expr.number]])) + * elif op != Operator.varidx: + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_const); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_v_op, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { + + /* "src/pyscipopt/expr.pxi":661 + * op = expr._op + * if op == Operator.const: # FIXME: constant expr should also have children! + * nodes.append(tuple([op, [expr.number]])) # <<<<<<<<<<<<<< + * elif op != Operator.varidx: + * indices = [] + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_number); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(1, 661, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_op); + __Pyx_GIVEREF(__pyx_v_op); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_op)) __PYX_ERR(1, 661, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_2)) __PYX_ERR(1, 661, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Append(__pyx_v_nodes, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 661, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":660 + * """adds expression to array""" + * op = expr._op + * if op == Operator.const: # FIXME: constant expr should also have children! # <<<<<<<<<<<<<< + * nodes.append(tuple([op, [expr.number]])) + * elif op != Operator.varidx: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":662 + * if op == Operator.const: # FIXME: constant expr should also have children! + * nodes.append(tuple([op, [expr.number]])) + * elif op != Operator.varidx: # <<<<<<<<<<<<<< + * indices = [] + * nchildren = len(expr.children) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_varidx); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_v_op, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 662, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 662, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_3) { + + /* "src/pyscipopt/expr.pxi":663 + * nodes.append(tuple([op, [expr.number]])) + * elif op != Operator.varidx: + * indices = [] # <<<<<<<<<<<<<< + * nchildren = len(expr.children) + * for child in expr.children: + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_indices = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":664 + * elif op != Operator.varidx: + * indices = [] + * nchildren = len(expr.children) # <<<<<<<<<<<<<< + * for child in expr.children: + * pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes' + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_children); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 664, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_nchildren = __pyx_t_5; + + /* "src/pyscipopt/expr.pxi":665 + * indices = [] + * nchildren = len(expr.children) + * for child in expr.children: # <<<<<<<<<<<<<< + * pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes' + * indices.append(pos) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_children); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 665, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 665, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 665, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 665, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(1, 665, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_6(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 665, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_child, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":666 + * nchildren = len(expr.children) + * for child in expr.children: + * pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes' # <<<<<<<<<<<<<< + * indices.append(pos) + * if op == Operator.power: + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_expr_to_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_child, __pyx_v_nodes}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_9, 2+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_XDECREF_SET(__pyx_v_pos, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":667 + * for child in expr.children: + * pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes' + * indices.append(pos) # <<<<<<<<<<<<<< + * if op == Operator.power: + * pos = value_to_array(expr.expo, nodes) + */ + __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_indices, __pyx_v_pos); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 667, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":665 + * indices = [] + * nchildren = len(expr.children) + * for child in expr.children: # <<<<<<<<<<<<<< + * pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes' + * indices.append(pos) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":668 + * pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes' + * indices.append(pos) + * if op == Operator.power: # <<<<<<<<<<<<<< + * pos = value_to_array(expr.expo, nodes) + * indices.append(pos) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_power); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_v_op, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 668, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 668, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { + + /* "src/pyscipopt/expr.pxi":669 + * indices.append(pos) + * if op == Operator.power: + * pos = value_to_array(expr.expo, nodes) # <<<<<<<<<<<<<< + * indices.append(pos) + * elif (op == Operator.add and expr.constant != 0.0) or (op == Operator.prod and expr.constant != 1.0): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_value_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_expo); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_7, __pyx_v_nodes}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_9, 2+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_XDECREF_SET(__pyx_v_pos, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":670 + * if op == Operator.power: + * pos = value_to_array(expr.expo, nodes) + * indices.append(pos) # <<<<<<<<<<<<<< + * elif (op == Operator.add and expr.constant != 0.0) or (op == Operator.prod and expr.constant != 1.0): + * pos = value_to_array(expr.constant, nodes) + */ + __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_indices, __pyx_v_pos); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 670, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":668 + * pos = expr_to_array(child, nodes) # position of child in the final array of nodes, 'nodes' + * indices.append(pos) + * if op == Operator.power: # <<<<<<<<<<<<<< + * pos = value_to_array(expr.expo, nodes) + * indices.append(pos) + */ + goto __pyx_L7; + } + + /* "src/pyscipopt/expr.pxi":671 + * pos = value_to_array(expr.expo, nodes) + * indices.append(pos) + * elif (op == Operator.add and expr.constant != 0.0) or (op == Operator.prod and expr.constant != 1.0): # <<<<<<<<<<<<<< + * pos = value_to_array(expr.constant, nodes) + * indices.append(pos) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_add_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_v_op, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!__pyx_t_10) { + goto __pyx_L9_next_or; + } else { + } + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_constant); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = (__Pyx_PyFloat_BoolNeObjC(__pyx_t_1, __pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!__pyx_t_10) { + } else { + __pyx_t_3 = __pyx_t_10; + goto __pyx_L8_bool_binop_done; + } + __pyx_L9_next_or:; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Operator); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_prod); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyObject_RichCompare(__pyx_v_op, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_10) { + } else { + __pyx_t_3 = __pyx_t_10; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_constant); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = (__Pyx_PyFloat_BoolNeObjC(__pyx_t_1, __pyx_float_1_0, 1.0, 0, 0)); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(1, 671, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_10; + __pyx_L8_bool_binop_done:; + if (__pyx_t_3) { + + /* "src/pyscipopt/expr.pxi":672 + * indices.append(pos) + * elif (op == Operator.add and expr.constant != 0.0) or (op == Operator.prod and expr.constant != 1.0): + * pos = value_to_array(expr.constant, nodes) # <<<<<<<<<<<<<< + * indices.append(pos) + * nodes.append( tuple( [op, indices] ) ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_value_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_constant); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_t_7, __pyx_v_nodes}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_9, 2+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_XDECREF_SET(__pyx_v_pos, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/expr.pxi":673 + * elif (op == Operator.add and expr.constant != 0.0) or (op == Operator.prod and expr.constant != 1.0): + * pos = value_to_array(expr.constant, nodes) + * indices.append(pos) # <<<<<<<<<<<<<< + * nodes.append( tuple( [op, indices] ) ) + * else: # var + */ + __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_indices, __pyx_v_pos); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 673, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":671 + * pos = value_to_array(expr.expo, nodes) + * indices.append(pos) + * elif (op == Operator.add and expr.constant != 0.0) or (op == Operator.prod and expr.constant != 1.0): # <<<<<<<<<<<<<< + * pos = value_to_array(expr.constant, nodes) + * indices.append(pos) + */ + } + __pyx_L7:; + + /* "src/pyscipopt/expr.pxi":674 + * pos = value_to_array(expr.constant, nodes) + * indices.append(pos) + * nodes.append( tuple( [op, indices] ) ) # <<<<<<<<<<<<<< + * else: # var + * nodes.append( tuple( [op, expr.children] ) ) + */ + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_op); + __Pyx_GIVEREF(__pyx_v_op); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_op)) __PYX_ERR(1, 674, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_indices); + __Pyx_GIVEREF(__pyx_v_indices); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 1, __pyx_v_indices)) __PYX_ERR(1, 674, __pyx_L1_error); + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Append(__pyx_v_nodes, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":662 + * if op == Operator.const: # FIXME: constant expr should also have children! + * nodes.append(tuple([op, [expr.number]])) + * elif op != Operator.varidx: # <<<<<<<<<<<<<< + * indices = [] + * nchildren = len(expr.children) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/expr.pxi":676 + * nodes.append( tuple( [op, indices] ) ) + * else: # var + * nodes.append( tuple( [op, expr.children] ) ) # <<<<<<<<<<<<<< + * return len(nodes) - 1 + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_children); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_op); + __Pyx_GIVEREF(__pyx_v_op); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_op)) __PYX_ERR(1, 676, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_2)) __PYX_ERR(1, 676, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Append(__pyx_v_nodes, __pyx_t_2); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 676, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/expr.pxi":677 + * else: # var + * nodes.append( tuple( [op, expr.children] ) ) + * return len(nodes) - 1 # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = PyObject_Length(__pyx_v_nodes); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 677, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_5 - 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/expr.pxi":657 + * # also, for sums, we are not considering coefficients, because basically all coefficients are 1 + * # haven't even consider substractions, but I guess we would interpret them as a - b = a + (-1) * b + * def expr_to_array(expr, nodes): # <<<<<<<<<<<<<< + * """adds expression to array""" + * op = expr._op + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.expr_to_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_op); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XDECREF(__pyx_v_child); + __Pyx_XDECREF(__pyx_v_pos); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":7 + * cdef readonly str name + * + * def __init__(self, name="LP", sense="minimize"): # <<<<<<<<<<<<<< + * """ + * Keyword arguments: + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_2LP_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP___init__, "\n Keyword arguments:\n name -- the name of the problem (default 'LP')\n sense -- objective sense (default minimize)\n "); +#if CYTHON_UPDATE_DESCRIPTOR_DOC +struct wrapperbase __pyx_wrapperbase_9pyscipopt_4scip_2LP___init__; +#endif +static int __pyx_pw_9pyscipopt_4scip_2LP_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_sense = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_sense,0}; + values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_n_u_LP)); + values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_n_u_minimize)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 7, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sense); + if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 7, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(2, 7, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_name = values[0]; + __pyx_v_sense = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 2, __pyx_nargs); __PYX_ERR(2, 7, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP___init__(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_name, __pyx_v_sense); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_2LP___init__(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_sense) { + PyObject *__pyx_v_n = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/lp.pxi":13 + * sense -- objective sense (default minimize) + * """ + * self.name = name # <<<<<<<<<<<<<< + * n = str_conversion(name) + * if sense == "minimize": + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(2, 13, __pyx_L1_error) + __pyx_t_1 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":14 + * """ + * self.name = name + * n = str_conversion(name) # <<<<<<<<<<<<<< + * if sense == "minimize": + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MINIMIZE)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":15 + * self.name = name + * n = str_conversion(name) + * if sense == "minimize": # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MINIMIZE)) + * elif sense == "maximize": + */ + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_sense, __pyx_n_u_minimize, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 15, __pyx_L1_error) + if (__pyx_t_5) { + + /* "src/pyscipopt/lp.pxi":16 + * n = str_conversion(name) + * if sense == "minimize": + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MINIMIZE)) # <<<<<<<<<<<<<< + * elif sense == "maximize": + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MAXIMIZE)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(2, 16, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiCreate((&__pyx_v_self->lpi), NULL, __pyx_t_6, SCIP_OBJSEN_MINIMIZE)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":15 + * self.name = name + * n = str_conversion(name) + * if sense == "minimize": # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MINIMIZE)) + * elif sense == "maximize": + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/lp.pxi":17 + * if sense == "minimize": + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MINIMIZE)) + * elif sense == "maximize": # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MAXIMIZE)) + * else: + */ + __pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_v_sense, __pyx_n_u_maximize, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 17, __pyx_L1_error) + if (likely(__pyx_t_5)) { + + /* "src/pyscipopt/lp.pxi":18 + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MINIMIZE)) + * elif sense == "maximize": + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MAXIMIZE)) # <<<<<<<<<<<<<< + * else: + * raise Warning("unrecognized objective sense") + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(2, 18, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiCreate((&__pyx_v_self->lpi), NULL, __pyx_t_6, SCIP_OBJSEN_MAXIMIZE)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":17 + * if sense == "minimize": + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MINIMIZE)) + * elif sense == "maximize": # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MAXIMIZE)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/lp.pxi":20 + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MAXIMIZE)) + * else: + * raise Warning("unrecognized objective sense") # <<<<<<<<<<<<<< + * + * def __dealloc__(self): + */ + /*else*/ { + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(2, 20, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/lp.pxi":7 + * cdef readonly str name + * + * def __init__(self, name="LP", sense="minimize"): # <<<<<<<<<<<<<< + * """ + * Keyword arguments: + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.LP.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":22 + * raise Warning("unrecognized objective sense") + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiFree(&(self.lpi))) + * + */ + +/* Python wrapper */ +static void __pyx_pw_9pyscipopt_4scip_2LP_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_9pyscipopt_4scip_2LP_3__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_pf_9pyscipopt_4scip_2LP_2__dealloc__(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_9pyscipopt_4scip_2LP_2__dealloc__(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__dealloc__", 1); + + /* "src/pyscipopt/lp.pxi":23 + * + * def __dealloc__(self): + * PY_SCIP_CALL(SCIPlpiFree(&(self.lpi))) # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiFree((&__pyx_v_self->lpi))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":22 + * raise Warning("unrecognized objective sense") + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiFree(&(self.lpi))) + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.LP.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "src/pyscipopt/lp.pxi":25 + * PY_SCIP_CALL(SCIPlpiFree(&(self.lpi))) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_5__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_5__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_4__repr__(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_4__repr__(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/lp.pxi":26 + * + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * def writeLP(self, filename): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":25 + * PY_SCIP_CALL(SCIPlpiFree(&(self.lpi))) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":28 + * return self.name + * + * def writeLP(self, filename): # <<<<<<<<<<<<<< + * """Writes LP to a file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_7writeLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_6writeLP, "LP.writeLP(self, filename)\nWrites LP to a file.\n\n Keyword arguments:\n filename -- the name of the file to be used\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_7writeLP = {"writeLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_7writeLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_6writeLP}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_7writeLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeLP (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 28, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeLP") < 0)) __PYX_ERR(2, 28, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_filename = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeLP", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 28, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.writeLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_6writeLP(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_filename); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_6writeLP(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + char const *__pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeLP", 1); + + /* "src/pyscipopt/lp.pxi":34 + * filename -- the name of the file to be used + * """ + * PY_SCIP_CALL(SCIPlpiWriteLP(self.lpi, filename)) # <<<<<<<<<<<<<< + * + * def readLP(self, filename): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_AsString(__pyx_v_filename); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(2, 34, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiWriteLP(__pyx_v_self->lpi, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":28 + * return self.name + * + * def writeLP(self, filename): # <<<<<<<<<<<<<< + * """Writes LP to a file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.LP.writeLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":36 + * PY_SCIP_CALL(SCIPlpiWriteLP(self.lpi, filename)) + * + * def readLP(self, filename): # <<<<<<<<<<<<<< + * """Reads LP from a file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_9readLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_8readLP, "LP.readLP(self, filename)\nReads LP from a file.\n\n Keyword arguments:\n filename -- the name of the file to be used\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_9readLP = {"readLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_9readLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_8readLP}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_9readLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readLP (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 36, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readLP") < 0)) __PYX_ERR(2, 36, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_filename = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("readLP", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 36, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.readLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_8readLP(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_filename); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_8readLP(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + char const *__pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("readLP", 1); + + /* "src/pyscipopt/lp.pxi":42 + * filename -- the name of the file to be used + * """ + * PY_SCIP_CALL(SCIPlpiReadLP(self.lpi, filename)) # <<<<<<<<<<<<<< + * + * def infinity(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_AsString(__pyx_v_filename); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(2, 42, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiReadLP(__pyx_v_self->lpi, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":36 + * PY_SCIP_CALL(SCIPlpiWriteLP(self.lpi, filename)) + * + * def readLP(self, filename): # <<<<<<<<<<<<<< + * """Reads LP from a file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.LP.readLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":44 + * PY_SCIP_CALL(SCIPlpiReadLP(self.lpi, filename)) + * + * def infinity(self): # <<<<<<<<<<<<<< + * """Returns infinity value of the LP. + * """ + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_11infinity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_10infinity, "LP.infinity(self)\nReturns infinity value of the LP.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_11infinity = {"infinity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_11infinity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_10infinity}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_11infinity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("infinity (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("infinity", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "infinity", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_10infinity(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_10infinity(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("infinity", 1); + + /* "src/pyscipopt/lp.pxi":47 + * """Returns infinity value of the LP. + * """ + * return SCIPlpiInfinity(self.lpi) # <<<<<<<<<<<<<< + * + * def isInfinity(self, val): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPlpiInfinity(__pyx_v_self->lpi)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":44 + * PY_SCIP_CALL(SCIPlpiReadLP(self.lpi, filename)) + * + * def infinity(self): # <<<<<<<<<<<<<< + * """Returns infinity value of the LP. + * """ + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.LP.infinity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":49 + * return SCIPlpiInfinity(self.lpi) + * + * def isInfinity(self, val): # <<<<<<<<<<<<<< + * """Checks if a given value is equal to the infinity value of the LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_13isInfinity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_12isInfinity, "LP.isInfinity(self, val)\nChecks if a given value is equal to the infinity value of the LP.\n\n Keyword arguments:\n val -- value that should be checked\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_13isInfinity = {"isInfinity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_13isInfinity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_12isInfinity}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_13isInfinity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_val = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isInfinity (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_val,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 49, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isInfinity") < 0)) __PYX_ERR(2, 49, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_val = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isInfinity", 1, 1, 1, __pyx_nargs); __PYX_ERR(2, 49, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.isInfinity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_12isInfinity(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_val); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_12isInfinity(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_val) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isInfinity", 1); + + /* "src/pyscipopt/lp.pxi":55 + * val -- value that should be checked + * """ + * return SCIPlpiIsInfinity(self.lpi, val) # <<<<<<<<<<<<<< + * + * def addCol(self, entries, obj = 0.0, lb = 0.0, ub = None): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 55, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(SCIPlpiIsInfinity(__pyx_v_self->lpi, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":49 + * return SCIPlpiInfinity(self.lpi) + * + * def isInfinity(self, val): # <<<<<<<<<<<<<< + * """Checks if a given value is equal to the infinity value of the LP. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.LP.isInfinity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":57 + * return SCIPlpiIsInfinity(self.lpi, val) + * + * def addCol(self, entries, obj = 0.0, lb = 0.0, ub = None): # <<<<<<<<<<<<<< + * """Adds a single column to the LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_15addCol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_14addCol, "LP.addCol(self, entries, obj=0.0, lb=0.0, ub=None)\nAdds a single column to the LP.\n\n Keyword arguments:\n entries -- list of tuples, each tuple consists of a row index and a coefficient\n obj -- objective coefficient (default 0.0)\n lb -- lower bound (default 0.0)\n ub -- upper bound (default infinity)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_15addCol = {"addCol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_15addCol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_14addCol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_15addCol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_entries = 0; + PyObject *__pyx_v_obj = 0; + PyObject *__pyx_v_lb = 0; + PyObject *__pyx_v_ub = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addCol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entries,&__pyx_n_s_obj,&__pyx_n_s_lb,&__pyx_n_s_ub,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_0_0)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_0_0)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_entries)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 57, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 57, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 57, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 57, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addCol") < 0)) __PYX_ERR(2, 57, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_entries = values[0]; + __pyx_v_obj = values[1]; + __pyx_v_lb = values[2]; + __pyx_v_ub = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addCol", 0, 1, 4, __pyx_nargs); __PYX_ERR(2, 57, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.addCol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_14addCol(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_entries, __pyx_v_obj, __pyx_v_lb, __pyx_v_ub); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_14addCol(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_entries, PyObject *__pyx_v_obj, PyObject *__pyx_v_lb, PyObject *__pyx_v_ub) { + PyObject *__pyx_v_nnonz = NULL; + SCIP_Real *__pyx_v_c_coefs; + int *__pyx_v_c_inds; + SCIP_Real __pyx_v_c_obj; + SCIP_Real __pyx_v_c_lb; + SCIP_Real __pyx_v_c_ub; + int __pyx_v_c_beg; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_entry = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + SCIP_Real __pyx_t_5; + int __pyx_t_6; + SCIP_Real __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + Py_ssize_t __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addCol", 1); + + /* "src/pyscipopt/lp.pxi":66 + * ub -- upper bound (default infinity) + * """ + * nnonz = len(entries) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + */ + __pyx_t_1 = PyObject_Length(__pyx_v_entries); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 66, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_nnonz = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":68 + * nnonz = len(entries) + * + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef int* c_inds = malloc(nnonz * sizeof(int)) + * cdef SCIP_Real c_obj + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_nnonz, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 68, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_coefs = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":69 + * + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * cdef int* c_inds = malloc(nnonz * sizeof(int)) # <<<<<<<<<<<<<< + * cdef SCIP_Real c_obj + * cdef SCIP_Real c_lb + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(int))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_nnonz, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 69, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_inds = ((int *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":75 + * cdef int c_beg + * + * c_obj = obj # <<<<<<<<<<<<<< + * c_lb = lb + * c_ub = ub if ub != None else self.infinity() + */ + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_obj); if (unlikely((__pyx_t_5 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 75, __pyx_L1_error) + __pyx_v_c_obj = __pyx_t_5; + + /* "src/pyscipopt/lp.pxi":76 + * + * c_obj = obj + * c_lb = lb # <<<<<<<<<<<<<< + * c_ub = ub if ub != None else self.infinity() + * c_beg = 0 + */ + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_5 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 76, __pyx_L1_error) + __pyx_v_c_lb = __pyx_t_5; + + /* "src/pyscipopt/lp.pxi":77 + * c_obj = obj + * c_lb = lb + * c_ub = ub if ub != None else self.infinity() # <<<<<<<<<<<<<< + * c_beg = 0 + * + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_ub, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 77, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(2, 77, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_6) { + __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_7 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 77, __pyx_L1_error) + __pyx_t_5 = __pyx_t_7; + } else { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_infinity); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_9, 0+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_7 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 77, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __pyx_t_7; + } + __pyx_v_c_ub = __pyx_t_5; + + /* "src/pyscipopt/lp.pxi":78 + * c_lb = lb + * c_ub = ub if ub != None else self.infinity() + * c_beg = 0 # <<<<<<<<<<<<<< + * + * for i,entry in enumerate(entries): + */ + __pyx_v_c_beg = 0; + + /* "src/pyscipopt/lp.pxi":80 + * c_beg = 0 + * + * for i,entry in enumerate(entries): # <<<<<<<<<<<<<< + * c_inds[i] = entry[0] + * c_coefs[i] = entry[1] + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_2 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_entries)) || PyTuple_CheckExact(__pyx_v_entries)) { + __pyx_t_3 = __pyx_v_entries; __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_entries); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 80, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 80, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_8); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 80, __pyx_L1_error) + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 80, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_8); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 80, __pyx_L1_error) + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_10(__pyx_t_3); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 80, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_8; + __pyx_t_8 = 0; + + /* "src/pyscipopt/lp.pxi":81 + * + * for i,entry in enumerate(entries): + * c_inds[i] = entry[0] # <<<<<<<<<<<<<< + * c_coefs[i] = entry[1] + * + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_entry, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 81, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 81, __pyx_L1_error) + (__pyx_v_c_inds[__pyx_t_11]) = __pyx_t_9; + + /* "src/pyscipopt/lp.pxi":82 + * for i,entry in enumerate(entries): + * c_inds[i] = entry[0] + * c_coefs[i] = entry[1] # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, 1, &c_obj, &c_lb, &c_ub, NULL, nnonz, &c_beg, c_inds, c_coefs)) + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_entry, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_8); if (unlikely((__pyx_t_5 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 82, __pyx_L1_error) + (__pyx_v_c_coefs[__pyx_t_11]) = __pyx_t_5; + + /* "src/pyscipopt/lp.pxi":80 + * c_beg = 0 + * + * for i,entry in enumerate(entries): # <<<<<<<<<<<<<< + * c_inds[i] = entry[0] + * c_coefs[i] = entry[1] + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":84 + * c_coefs[i] = entry[1] + * + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, 1, &c_obj, &c_lb, &c_ub, NULL, nnonz, &c_beg, c_inds, c_coefs)) # <<<<<<<<<<<<<< + * + * free(c_coefs) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_nnonz); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 84, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiAddCols(__pyx_v_self->lpi, 1, (&__pyx_v_c_obj), (&__pyx_v_c_lb), (&__pyx_v_c_ub), NULL, __pyx_t_9, (&__pyx_v_c_beg), __pyx_v_c_inds, __pyx_v_c_coefs)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_12 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":86 + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, 1, &c_obj, &c_lb, &c_ub, NULL, nnonz, &c_beg, c_inds, c_coefs)) + * + * free(c_coefs) # <<<<<<<<<<<<<< + * free(c_inds) + * + */ + free(__pyx_v_c_coefs); + + /* "src/pyscipopt/lp.pxi":87 + * + * free(c_coefs) + * free(c_inds) # <<<<<<<<<<<<<< + * + * def addCols(self, entrieslist, objs = None, lbs = None, ubs = None): + */ + free(__pyx_v_c_inds); + + /* "src/pyscipopt/lp.pxi":57 + * return SCIPlpiIsInfinity(self.lpi, val) + * + * def addCol(self, entries, obj = 0.0, lb = 0.0, ub = None): # <<<<<<<<<<<<<< + * """Adds a single column to the LP. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("pyscipopt.scip.LP.addCol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nnonz); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_entry); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":89 + * free(c_inds) + * + * def addCols(self, entrieslist, objs = None, lbs = None, ubs = None): # <<<<<<<<<<<<<< + * """Adds multiple columns to the LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_17addCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_16addCols, "LP.addCols(self, entrieslist, objs=None, lbs=None, ubs=None)\nAdds multiple columns to the LP.\n\n Keyword arguments:\n entrieslist -- list containing lists of tuples, each tuple contains a coefficient and a row index\n objs -- objective coefficient (default 0.0)\n lbs -- lower bounds (default 0.0)\n ubs -- upper bounds (default infinity)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_17addCols = {"addCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_17addCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_16addCols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_17addCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_entrieslist = 0; + PyObject *__pyx_v_objs = 0; + PyObject *__pyx_v_lbs = 0; + PyObject *__pyx_v_ubs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addCols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entrieslist,&__pyx_n_s_objs,&__pyx_n_s_lbs,&__pyx_n_s_ubs,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_entrieslist)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 89, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_objs); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 89, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lbs); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 89, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ubs); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 89, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addCols") < 0)) __PYX_ERR(2, 89, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_entrieslist = values[0]; + __pyx_v_objs = values[1]; + __pyx_v_lbs = values[2]; + __pyx_v_ubs = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addCols", 0, 1, 4, __pyx_nargs); __PYX_ERR(2, 89, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.addCols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_16addCols(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_entrieslist, __pyx_v_objs, __pyx_v_lbs, __pyx_v_ubs); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_9pyscipopt_4scip_2LP_7addCols_2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "src/pyscipopt/lp.pxi":100 + * + * ncols = len(entrieslist) + * nnonz = sum(len(entries) for entries in entrieslist) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_objs = malloc(ncols * sizeof(SCIP_Real)) + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_7addCols_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_2_genexpr(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(2, 100, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_9pyscipopt_4scip_2LP_7addCols_2generator2, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_addCols_locals_genexpr, __pyx_n_s_pyscipopt_scip); if (unlikely(!gen)) __PYX_ERR(2, 100, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.LP.addCols.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_9pyscipopt_4scip_2LP_7addCols_2generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *__pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 100, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(2, 100, __pyx_L1_error) } + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 100, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 100, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(2, 100, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 100, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(2, 100, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 100, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_entries); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_entries, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_5 = PyObject_Length(__pyx_cur_scope->__pyx_v_entries); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 100, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 100, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":89 + * free(c_inds) + * + * def addCols(self, entrieslist, objs = None, lbs = None, ubs = None): # <<<<<<<<<<<<<< + * """Adds multiple columns to the LP. + * + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_16addCols(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_entrieslist, PyObject *__pyx_v_objs, PyObject *__pyx_v_lbs, PyObject *__pyx_v_ubs) { + PyObject *__pyx_v_ncols = NULL; + PyObject *__pyx_v_nnonz = NULL; + SCIP_Real *__pyx_v_c_objs; + SCIP_Real *__pyx_v_c_lbs; + SCIP_Real *__pyx_v_c_ubs; + SCIP_Real *__pyx_v_c_coefs; + int *__pyx_v_c_inds; + int *__pyx_v_c_beg; + PyObject *__pyx_v_tmp = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_entries = NULL; + PyObject *__pyx_v_entry = NULL; + PyObject *__pyx_gb_9pyscipopt_4scip_2LP_7addCols_2generator2 = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + SCIP_Real __pyx_t_8; + SCIP_Real __pyx_t_9; + Py_ssize_t __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + PyObject *(*__pyx_t_14)(PyObject *); + Py_ssize_t __pyx_t_15; + int __pyx_t_16; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addCols", 1); + + /* "src/pyscipopt/lp.pxi":99 + * """ + * + * ncols = len(entrieslist) # <<<<<<<<<<<<<< + * nnonz = sum(len(entries) for entries in entrieslist) + * + */ + __pyx_t_1 = PyObject_Length(__pyx_v_entrieslist); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 99, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_ncols = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":100 + * + * ncols = len(entrieslist) + * nnonz = sum(len(entries) for entries in entrieslist) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_objs = malloc(ncols * sizeof(SCIP_Real)) + */ + __pyx_t_2 = __pyx_pf_9pyscipopt_4scip_2LP_7addCols_genexpr(NULL, __pyx_v_entrieslist); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_nnonz = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":102 + * nnonz = sum(len(entries) for entries in entrieslist) + * + * cdef SCIP_Real* c_objs = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_objs = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":103 + * + * cdef SCIP_Real* c_objs = malloc(ncols * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_coefs + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 103, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_lbs = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":104 + * cdef SCIP_Real* c_objs = malloc(ncols * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_coefs + * cdef int* c_inds + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 104, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_ubs = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":110 + * + * + * if nnonz > 0: # <<<<<<<<<<<<<< + * c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * c_inds = malloc(nnonz * sizeof(int)) + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_nnonz, __pyx_int_0, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 110, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/lp.pxi":111 + * + * if nnonz > 0: + * c_coefs = malloc(nnonz * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * c_inds = malloc(nnonz * sizeof(int)) + * c_beg = malloc(ncols * sizeof(int)) + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_nnonz, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_coefs = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":112 + * if nnonz > 0: + * c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * c_inds = malloc(nnonz * sizeof(int)) # <<<<<<<<<<<<<< + * c_beg = malloc(ncols * sizeof(int)) + * + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(int))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_nnonz, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 112, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_inds = ((int *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":113 + * c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * c_inds = malloc(nnonz * sizeof(int)) + * c_beg = malloc(ncols * sizeof(int)) # <<<<<<<<<<<<<< + * + * tmp = 0 + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(int))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 113, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_beg = ((int *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":115 + * c_beg = malloc(ncols * sizeof(int)) + * + * tmp = 0 # <<<<<<<<<<<<<< + * for i,entries in enumerate(entrieslist): + * c_objs[i] = objs[i] if objs != None else 0.0 + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_tmp = __pyx_int_0; + + /* "src/pyscipopt/lp.pxi":116 + * + * tmp = 0 + * for i,entries in enumerate(entrieslist): # <<<<<<<<<<<<<< + * c_objs[i] = objs[i] if objs != None else 0.0 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_entrieslist)) || PyTuple_CheckExact(__pyx_v_entrieslist)) { + __pyx_t_2 = __pyx_v_entrieslist; __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_entrieslist); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 116, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 116, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_1); __Pyx_INCREF(__pyx_t_7); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 116, __pyx_L1_error) + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 116, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_1); __Pyx_INCREF(__pyx_t_7); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 116, __pyx_L1_error) + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_2); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 116, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_entries, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "src/pyscipopt/lp.pxi":117 + * tmp = 0 + * for i,entries in enumerate(entrieslist): + * c_objs[i] = objs[i] if objs != None else 0.0 # <<<<<<<<<<<<<< + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + * c_ubs[i] = ubs[i] if ubs != None else self.infinity() + */ + __pyx_t_7 = PyObject_RichCompare(__pyx_v_objs, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 117, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_5) { + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_objs, __pyx_v_i); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __pyx_t_9; + } else { + __pyx_t_8 = 0.0; + } + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 117, __pyx_L1_error) + (__pyx_v_c_objs[__pyx_t_10]) = __pyx_t_8; + + /* "src/pyscipopt/lp.pxi":118 + * for i,entries in enumerate(entrieslist): + * c_objs[i] = objs[i] if objs != None else 0.0 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 # <<<<<<<<<<<<<< + * c_ubs[i] = ubs[i] if ubs != None else self.infinity() + * c_beg[i] = tmp + */ + __pyx_t_7 = PyObject_RichCompare(__pyx_v_lbs, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 118, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_5) { + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_lbs, __pyx_v_i); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __pyx_t_9; + } else { + __pyx_t_8 = 0.0; + } + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 118, __pyx_L1_error) + (__pyx_v_c_lbs[__pyx_t_10]) = __pyx_t_8; + + /* "src/pyscipopt/lp.pxi":119 + * c_objs[i] = objs[i] if objs != None else 0.0 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + * c_ubs[i] = ubs[i] if ubs != None else self.infinity() # <<<<<<<<<<<<<< + * c_beg[i] = tmp + * + */ + __pyx_t_7 = PyObject_RichCompare(__pyx_v_ubs, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 119, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_5) { + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_ubs, __pyx_v_i); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __pyx_t_9; + } else { + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_infinity); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = NULL; + __pyx_t_13 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_11, function); + __pyx_t_13 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+1-__pyx_t_13, 0+__pyx_t_13); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __pyx_t_9; + } + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 119, __pyx_L1_error) + (__pyx_v_c_ubs[__pyx_t_10]) = __pyx_t_8; + + /* "src/pyscipopt/lp.pxi":120 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + * c_ubs[i] = ubs[i] if ubs != None else self.infinity() + * c_beg[i] = tmp # <<<<<<<<<<<<<< + * + * for entry in entries: + */ + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_tmp); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 120, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 120, __pyx_L1_error) + (__pyx_v_c_beg[__pyx_t_10]) = __pyx_t_13; + + /* "src/pyscipopt/lp.pxi":122 + * c_beg[i] = tmp + * + * for entry in entries: # <<<<<<<<<<<<<< + * c_inds[tmp] = entry[0] + * c_coefs[tmp] = entry[1] + */ + if (likely(PyList_CheckExact(__pyx_v_entries)) || PyTuple_CheckExact(__pyx_v_entries)) { + __pyx_t_7 = __pyx_v_entries; __Pyx_INCREF(__pyx_t_7); + __pyx_t_10 = 0; + __pyx_t_14 = NULL; + } else { + __pyx_t_10 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_entries); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_14 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 122, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_14)) { + if (likely(PyList_CheckExact(__pyx_t_7))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 122, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_10); __Pyx_INCREF(__pyx_t_11); __pyx_t_10++; if (unlikely((0 < 0))) __PYX_ERR(2, 122, __pyx_L1_error) + #else + __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 122, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_10); __Pyx_INCREF(__pyx_t_11); __pyx_t_10++; if (unlikely((0 < 0))) __PYX_ERR(2, 122, __pyx_L1_error) + #else + __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + #endif + } + } else { + __pyx_t_11 = __pyx_t_14(__pyx_t_7); + if (unlikely(!__pyx_t_11)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 122, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_11); + } + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_11); + __pyx_t_11 = 0; + + /* "src/pyscipopt/lp.pxi":123 + * + * for entry in entries: + * c_inds[tmp] = entry[0] # <<<<<<<<<<<<<< + * c_coefs[tmp] = entry[1] + * tmp += 1 + */ + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_entry, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 123, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_15 = __Pyx_PyIndex_AsSsize_t(__pyx_v_tmp); if (unlikely((__pyx_t_15 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 123, __pyx_L1_error) + (__pyx_v_c_inds[__pyx_t_15]) = __pyx_t_13; + + /* "src/pyscipopt/lp.pxi":124 + * for entry in entries: + * c_inds[tmp] = entry[0] + * c_coefs[tmp] = entry[1] # <<<<<<<<<<<<<< + * tmp += 1 + * + */ + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_entry, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_t_11); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 124, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_15 = __Pyx_PyIndex_AsSsize_t(__pyx_v_tmp); if (unlikely((__pyx_t_15 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 124, __pyx_L1_error) + (__pyx_v_c_coefs[__pyx_t_15]) = __pyx_t_8; + + /* "src/pyscipopt/lp.pxi":125 + * c_inds[tmp] = entry[0] + * c_coefs[tmp] = entry[1] + * tmp += 1 # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, ncols, c_objs, c_lbs, c_ubs, NULL, nnonz, c_beg, c_inds, c_coefs)) + */ + __pyx_t_11 = __Pyx_PyInt_AddObjC(__pyx_v_tmp, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF_SET(__pyx_v_tmp, __pyx_t_11); + __pyx_t_11 = 0; + + /* "src/pyscipopt/lp.pxi":122 + * c_beg[i] = tmp + * + * for entry in entries: # <<<<<<<<<<<<<< + * c_inds[tmp] = entry[0] + * c_coefs[tmp] = entry[1] + */ + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/lp.pxi":116 + * + * tmp = 0 + * for i,entries in enumerate(entrieslist): # <<<<<<<<<<<<<< + * c_objs[i] = objs[i] if objs != None else 0.0 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":127 + * tmp += 1 + * + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, ncols, c_objs, c_lbs, c_ubs, NULL, nnonz, c_beg, c_inds, c_coefs)) # <<<<<<<<<<<<<< + * + * free(c_beg) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_ncols); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 127, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_v_nnonz); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 127, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiAddCols(__pyx_v_self->lpi, __pyx_t_13, __pyx_v_c_objs, __pyx_v_c_lbs, __pyx_v_c_ubs, NULL, __pyx_t_16, __pyx_v_c_beg, __pyx_v_c_inds, __pyx_v_c_coefs)); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = NULL; + __pyx_t_16 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_16 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_16, 1+__pyx_t_16); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":129 + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, ncols, c_objs, c_lbs, c_ubs, NULL, nnonz, c_beg, c_inds, c_coefs)) + * + * free(c_beg) # <<<<<<<<<<<<<< + * free(c_inds) + * free(c_coefs) + */ + free(__pyx_v_c_beg); + + /* "src/pyscipopt/lp.pxi":130 + * + * free(c_beg) + * free(c_inds) # <<<<<<<<<<<<<< + * free(c_coefs) + * else: + */ + free(__pyx_v_c_inds); + + /* "src/pyscipopt/lp.pxi":131 + * free(c_beg) + * free(c_inds) + * free(c_coefs) # <<<<<<<<<<<<<< + * else: + * for i in range(len(entrieslist)): + */ + free(__pyx_v_c_coefs); + + /* "src/pyscipopt/lp.pxi":110 + * + * + * if nnonz > 0: # <<<<<<<<<<<<<< + * c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * c_inds = malloc(nnonz * sizeof(int)) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/lp.pxi":133 + * free(c_coefs) + * else: + * for i in range(len(entrieslist)): # <<<<<<<<<<<<<< + * c_objs[i] = objs[i] if objs != None else 0.0 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + */ + /*else*/ { + __pyx_t_1 = PyObject_Length(__pyx_v_entrieslist); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 133, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 133, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 133, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_2); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 133, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 133, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_2); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 133, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_6(__pyx_t_3); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 133, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":134 + * else: + * for i in range(len(entrieslist)): + * c_objs[i] = objs[i] if objs != None else 0.0 # <<<<<<<<<<<<<< + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + * c_ubs[i] = ubs[i] if ubs != None else self.infinity() + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_objs, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 134, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 134, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_objs, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 134, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __pyx_t_9; + } else { + __pyx_t_8 = 0.0; + } + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 134, __pyx_L1_error) + (__pyx_v_c_objs[__pyx_t_10]) = __pyx_t_8; + + /* "src/pyscipopt/lp.pxi":135 + * for i in range(len(entrieslist)): + * c_objs[i] = objs[i] if objs != None else 0.0 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 # <<<<<<<<<<<<<< + * c_ubs[i] = ubs[i] if ubs != None else self.infinity() + * + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_lbs, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 135, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 135, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_lbs, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 135, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __pyx_t_9; + } else { + __pyx_t_8 = 0.0; + } + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 135, __pyx_L1_error) + (__pyx_v_c_lbs[__pyx_t_10]) = __pyx_t_8; + + /* "src/pyscipopt/lp.pxi":136 + * c_objs[i] = objs[i] if objs != None else 0.0 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + * c_ubs[i] = ubs[i] if ubs != None else self.infinity() # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, ncols, c_objs, c_lbs, c_ubs, NULL, 0, NULL, NULL, NULL)) + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_ubs, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 136, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(2, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_ubs, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __pyx_t_9; + } else { + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_infinity); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = NULL; + __pyx_t_16 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_16 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_16, 0+__pyx_t_16); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __pyx_t_9; + } + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 136, __pyx_L1_error) + (__pyx_v_c_ubs[__pyx_t_10]) = __pyx_t_8; + + /* "src/pyscipopt/lp.pxi":133 + * free(c_coefs) + * else: + * for i in range(len(entrieslist)): # <<<<<<<<<<<<<< + * c_objs[i] = objs[i] if objs != None else 0.0 + * c_lbs[i] = lbs[i] if lbs != None else 0.0 + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":138 + * c_ubs[i] = ubs[i] if ubs != None else self.infinity() + * + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, ncols, c_objs, c_lbs, c_ubs, NULL, 0, NULL, NULL, NULL)) # <<<<<<<<<<<<<< + * + * free(c_ubs) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_v_ncols); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 138, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiAddCols(__pyx_v_self->lpi, __pyx_t_16, __pyx_v_c_objs, __pyx_v_c_lbs, __pyx_v_c_ubs, NULL, 0, NULL, NULL, NULL)); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = NULL; + __pyx_t_16 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_16 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_16, 1+__pyx_t_16); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/lp.pxi":140 + * PY_SCIP_CALL(SCIPlpiAddCols(self.lpi, ncols, c_objs, c_lbs, c_ubs, NULL, 0, NULL, NULL, NULL)) + * + * free(c_ubs) # <<<<<<<<<<<<<< + * free(c_lbs) + * free(c_objs) + */ + free(__pyx_v_c_ubs); + + /* "src/pyscipopt/lp.pxi":141 + * + * free(c_ubs) + * free(c_lbs) # <<<<<<<<<<<<<< + * free(c_objs) + * + */ + free(__pyx_v_c_lbs); + + /* "src/pyscipopt/lp.pxi":142 + * free(c_ubs) + * free(c_lbs) + * free(c_objs) # <<<<<<<<<<<<<< + * + * def delCols(self, firstcol, lastcol): + */ + free(__pyx_v_c_objs); + + /* "src/pyscipopt/lp.pxi":89 + * free(c_inds) + * + * def addCols(self, entrieslist, objs = None, lbs = None, ubs = None): # <<<<<<<<<<<<<< + * """Adds multiple columns to the LP. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("pyscipopt.scip.LP.addCols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ncols); + __Pyx_XDECREF(__pyx_v_nnonz); + __Pyx_XDECREF(__pyx_v_tmp); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_entries); + __Pyx_XDECREF(__pyx_v_entry); + __Pyx_XDECREF(__pyx_gb_9pyscipopt_4scip_2LP_7addCols_2generator2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":144 + * free(c_objs) + * + * def delCols(self, firstcol, lastcol): # <<<<<<<<<<<<<< + * """Deletes a range of columns from the LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_19delCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_18delCols, "LP.delCols(self, firstcol, lastcol)\nDeletes a range of columns from the LP.\n\n Keyword arguments:\n firstcol -- first column to delete\n lastcol -- last column to delete\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_19delCols = {"delCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_19delCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_18delCols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_19delCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_firstcol = 0; + PyObject *__pyx_v_lastcol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("delCols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_firstcol,&__pyx_n_s_lastcol,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_firstcol)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 144, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lastcol)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 144, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("delCols", 1, 2, 2, 1); __PYX_ERR(2, 144, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delCols") < 0)) __PYX_ERR(2, 144, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_firstcol = values[0]; + __pyx_v_lastcol = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delCols", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 144, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.delCols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_18delCols(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_firstcol, __pyx_v_lastcol); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_18delCols(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_firstcol, PyObject *__pyx_v_lastcol) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("delCols", 1); + + /* "src/pyscipopt/lp.pxi":151 + * lastcol -- last column to delete + * """ + * PY_SCIP_CALL(SCIPlpiDelCols(self.lpi, firstcol, lastcol)) # <<<<<<<<<<<<<< + * + * def addRow(self, entries, lhs=0.0, rhs=None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_firstcol); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 151, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_lastcol); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 151, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiDelCols(__pyx_v_self->lpi, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":144 + * free(c_objs) + * + * def delCols(self, firstcol, lastcol): # <<<<<<<<<<<<<< + * """Deletes a range of columns from the LP. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.delCols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":153 + * PY_SCIP_CALL(SCIPlpiDelCols(self.lpi, firstcol, lastcol)) + * + * def addRow(self, entries, lhs=0.0, rhs=None): # <<<<<<<<<<<<<< + * """Adds a single row to the LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_21addRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_20addRow, "LP.addRow(self, entries, lhs=0.0, rhs=None)\nAdds a single row to the LP.\n\n Keyword arguments:\n entries -- list of tuples, each tuple contains a coefficient and a column index\n lhs -- left-hand side of the row (default 0.0)\n rhs -- right-hand side of the row (default infinity)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_21addRow = {"addRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_21addRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_20addRow}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_21addRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_entries = 0; + PyObject *__pyx_v_lhs = 0; + PyObject *__pyx_v_rhs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addRow (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entries,&__pyx_n_s_lhs,&__pyx_n_s_rhs,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_0_0)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_entries)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 153, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lhs); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 153, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rhs); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 153, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addRow") < 0)) __PYX_ERR(2, 153, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_entries = values[0]; + __pyx_v_lhs = values[1]; + __pyx_v_rhs = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addRow", 0, 1, 3, __pyx_nargs); __PYX_ERR(2, 153, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.addRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_20addRow(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_entries, __pyx_v_lhs, __pyx_v_rhs); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_20addRow(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_entries, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs) { + CYTHON_UNUSED long __pyx_v_beg; + PyObject *__pyx_v_nnonz = NULL; + SCIP_Real *__pyx_v_c_coefs; + int *__pyx_v_c_inds; + SCIP_Real __pyx_v_c_lhs; + SCIP_Real __pyx_v_c_rhs; + int __pyx_v_c_beg; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_entry = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + SCIP_Real __pyx_t_5; + int __pyx_t_6; + SCIP_Real __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + Py_ssize_t __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addRow", 1); + + /* "src/pyscipopt/lp.pxi":161 + * rhs -- right-hand side of the row (default infinity) + * """ + * beg = 0 # <<<<<<<<<<<<<< + * nnonz = len(entries) + * + */ + __pyx_v_beg = 0; + + /* "src/pyscipopt/lp.pxi":162 + * """ + * beg = 0 + * nnonz = len(entries) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + */ + __pyx_t_1 = PyObject_Length(__pyx_v_entries); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 162, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_nnonz = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":164 + * nnonz = len(entries) + * + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef int* c_inds = malloc(nnonz * sizeof(int)) + * cdef SCIP_Real c_lhs + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_nnonz, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 164, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_coefs = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":165 + * + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * cdef int* c_inds = malloc(nnonz * sizeof(int)) # <<<<<<<<<<<<<< + * cdef SCIP_Real c_lhs + * cdef SCIP_Real c_rhs + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(int))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_nnonz, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 165, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_inds = ((int *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":170 + * cdef int c_beg + * + * c_lhs = lhs # <<<<<<<<<<<<<< + * c_rhs = rhs if rhs != None else self.infinity() + * c_beg = 0 + */ + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_lhs); if (unlikely((__pyx_t_5 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 170, __pyx_L1_error) + __pyx_v_c_lhs = __pyx_t_5; + + /* "src/pyscipopt/lp.pxi":171 + * + * c_lhs = lhs + * c_rhs = rhs if rhs != None else self.infinity() # <<<<<<<<<<<<<< + * c_beg = 0 + * + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_rhs, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 171, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(2, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_6) { + __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_v_rhs); if (unlikely((__pyx_t_7 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 171, __pyx_L1_error) + __pyx_t_5 = __pyx_t_7; + } else { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_infinity); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_9, 0+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_7 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __pyx_t_7; + } + __pyx_v_c_rhs = __pyx_t_5; + + /* "src/pyscipopt/lp.pxi":172 + * c_lhs = lhs + * c_rhs = rhs if rhs != None else self.infinity() + * c_beg = 0 # <<<<<<<<<<<<<< + * + * for i,entry in enumerate(entries): + */ + __pyx_v_c_beg = 0; + + /* "src/pyscipopt/lp.pxi":174 + * c_beg = 0 + * + * for i,entry in enumerate(entries): # <<<<<<<<<<<<<< + * c_inds[i] = entry[0] + * c_coefs[i] = entry[1] + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_2 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_entries)) || PyTuple_CheckExact(__pyx_v_entries)) { + __pyx_t_3 = __pyx_v_entries; __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_entries); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 174, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 174, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_8); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 174, __pyx_L1_error) + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 174, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_8); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 174, __pyx_L1_error) + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_10(__pyx_t_3); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 174, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_8; + __pyx_t_8 = 0; + + /* "src/pyscipopt/lp.pxi":175 + * + * for i,entry in enumerate(entries): + * c_inds[i] = entry[0] # <<<<<<<<<<<<<< + * c_coefs[i] = entry[1] + * + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_entry, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 175, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 175, __pyx_L1_error) + (__pyx_v_c_inds[__pyx_t_11]) = __pyx_t_9; + + /* "src/pyscipopt/lp.pxi":176 + * for i,entry in enumerate(entries): + * c_inds[i] = entry[0] + * c_coefs[i] = entry[1] # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPlpiAddRows(self.lpi, 1, &c_lhs, &c_rhs, NULL, nnonz, &c_beg, c_inds, c_coefs)) + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_entry, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_t_8); if (unlikely((__pyx_t_5 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 176, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 176, __pyx_L1_error) + (__pyx_v_c_coefs[__pyx_t_11]) = __pyx_t_5; + + /* "src/pyscipopt/lp.pxi":174 + * c_beg = 0 + * + * for i,entry in enumerate(entries): # <<<<<<<<<<<<<< + * c_inds[i] = entry[0] + * c_coefs[i] = entry[1] + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":178 + * c_coefs[i] = entry[1] + * + * PY_SCIP_CALL(SCIPlpiAddRows(self.lpi, 1, &c_lhs, &c_rhs, NULL, nnonz, &c_beg, c_inds, c_coefs)) # <<<<<<<<<<<<<< + * + * free(c_coefs) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_nnonz); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 178, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiAddRows(__pyx_v_self->lpi, 1, (&__pyx_v_c_lhs), (&__pyx_v_c_rhs), NULL, __pyx_t_9, (&__pyx_v_c_beg), __pyx_v_c_inds, __pyx_v_c_coefs)); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_12 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":180 + * PY_SCIP_CALL(SCIPlpiAddRows(self.lpi, 1, &c_lhs, &c_rhs, NULL, nnonz, &c_beg, c_inds, c_coefs)) + * + * free(c_coefs) # <<<<<<<<<<<<<< + * free(c_inds) + * + */ + free(__pyx_v_c_coefs); + + /* "src/pyscipopt/lp.pxi":181 + * + * free(c_coefs) + * free(c_inds) # <<<<<<<<<<<<<< + * + * def addRows(self, entrieslist, lhss = None, rhss = None): + */ + free(__pyx_v_c_inds); + + /* "src/pyscipopt/lp.pxi":153 + * PY_SCIP_CALL(SCIPlpiDelCols(self.lpi, firstcol, lastcol)) + * + * def addRow(self, entries, lhs=0.0, rhs=None): # <<<<<<<<<<<<<< + * """Adds a single row to the LP. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("pyscipopt.scip.LP.addRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nnonz); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_entry); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":183 + * free(c_inds) + * + * def addRows(self, entrieslist, lhss = None, rhss = None): # <<<<<<<<<<<<<< + * """Adds multiple rows to the LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_23addRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_22addRows, "LP.addRows(self, entrieslist, lhss=None, rhss=None)\nAdds multiple rows to the LP.\n\n Keyword arguments:\n entrieslist -- list containing lists of tuples, each tuple contains a coefficient and a column index\n lhss -- left-hand side of the row (default 0.0)\n rhss -- right-hand side of the row (default infinity)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_23addRows = {"addRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_23addRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_22addRows}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_23addRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_entrieslist = 0; + PyObject *__pyx_v_lhss = 0; + PyObject *__pyx_v_rhss = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addRows (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entrieslist,&__pyx_n_s_lhss,&__pyx_n_s_rhss,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_entrieslist)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 183, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lhss); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 183, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rhss); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 183, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addRows") < 0)) __PYX_ERR(2, 183, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_entrieslist = values[0]; + __pyx_v_lhss = values[1]; + __pyx_v_rhss = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addRows", 0, 1, 3, __pyx_nargs); __PYX_ERR(2, 183, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.addRows", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_22addRows(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_entrieslist, __pyx_v_lhss, __pyx_v_rhss); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_9pyscipopt_4scip_2LP_7addRows_2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "src/pyscipopt/lp.pxi":192 + * """ + * nrows = len(entrieslist) + * nnonz = sum(len(entries) for entries in entrieslist) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_7addRows_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_3_genexpr(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(2, 192, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_9pyscipopt_4scip_2LP_7addRows_2generator3, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_addRows_locals_genexpr, __pyx_n_s_pyscipopt_scip); if (unlikely(!gen)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.LP.addRows.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_9pyscipopt_4scip_2LP_7addRows_2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *__pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *(*__pyx_t_3)(PyObject *); + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 192, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(2, 192, __pyx_L1_error) } + if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_genexpr_arg_0)) { + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + __pyx_t_3 = NULL; + } else { + __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_cur_scope->__pyx_genexpr_arg_0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_3)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 192, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(2, 192, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 192, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(2, 192, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_3(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 192, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_entries); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_entries, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_5 = PyObject_Length(__pyx_cur_scope->__pyx_v_entries); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(2, 192, __pyx_L1_error) + __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 192, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":183 + * free(c_inds) + * + * def addRows(self, entrieslist, lhss = None, rhss = None): # <<<<<<<<<<<<<< + * """Adds multiple rows to the LP. + * + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_22addRows(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_entrieslist, PyObject *__pyx_v_lhss, PyObject *__pyx_v_rhss) { + PyObject *__pyx_v_nrows = NULL; + PyObject *__pyx_v_nnonz = NULL; + SCIP_Real *__pyx_v_c_lhss; + SCIP_Real *__pyx_v_c_rhss; + SCIP_Real *__pyx_v_c_coefs; + int *__pyx_v_c_inds; + int *__pyx_v_c_beg; + PyObject *__pyx_v_tmp = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_entries = NULL; + PyObject *__pyx_v_entry = NULL; + PyObject *__pyx_gb_9pyscipopt_4scip_2LP_7addRows_2generator3 = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *(*__pyx_t_5)(PyObject *); + PyObject *__pyx_t_6 = NULL; + SCIP_Real __pyx_t_7; + int __pyx_t_8; + SCIP_Real __pyx_t_9; + Py_ssize_t __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + PyObject *(*__pyx_t_14)(PyObject *); + Py_ssize_t __pyx_t_15; + int __pyx_t_16; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addRows", 1); + + /* "src/pyscipopt/lp.pxi":191 + * rhss -- right-hand side of the row (default infinity) + * """ + * nrows = len(entrieslist) # <<<<<<<<<<<<<< + * nnonz = sum(len(entries) for entries in entrieslist) + * + */ + __pyx_t_1 = PyObject_Length(__pyx_v_entrieslist); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(2, 191, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_nrows = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":192 + * """ + * nrows = len(entrieslist) + * nnonz = sum(len(entries) for entries in entrieslist) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + */ + __pyx_t_2 = __pyx_pf_9pyscipopt_4scip_2LP_7addRows_genexpr(NULL, __pyx_v_entrieslist); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_nnonz = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":194 + * nnonz = sum(len(entries) for entries in entrieslist) + * + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_nrows, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 194, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_lhss = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":195 + * + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * cdef int* c_inds = malloc(nnonz * sizeof(int)) + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_nrows, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 195, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_rhss = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":196 + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef int* c_inds = malloc(nnonz * sizeof(int)) + * cdef int* c_beg = malloc(nrows * sizeof(int)) + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_nnonz, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 196, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_coefs = ((SCIP_Real *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":197 + * cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * cdef int* c_inds = malloc(nnonz * sizeof(int)) # <<<<<<<<<<<<<< + * cdef int* c_beg = malloc(nrows * sizeof(int)) + * + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(int))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_nnonz, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_inds = ((int *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":198 + * cdef SCIP_Real* c_coefs = malloc(nnonz * sizeof(SCIP_Real)) + * cdef int* c_inds = malloc(nnonz * sizeof(int)) + * cdef int* c_beg = malloc(nrows * sizeof(int)) # <<<<<<<<<<<<<< + * + * tmp = 0 + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(int))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_nrows, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_4 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 198, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_beg = ((int *)malloc(__pyx_t_4)); + + /* "src/pyscipopt/lp.pxi":200 + * cdef int* c_beg = malloc(nrows * sizeof(int)) + * + * tmp = 0 # <<<<<<<<<<<<<< + * for i,entries in enumerate(entrieslist): + * c_lhss[i] = lhss[i] if lhss != None else 0.0 + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_tmp = __pyx_int_0; + + /* "src/pyscipopt/lp.pxi":201 + * + * tmp = 0 + * for i,entries in enumerate(entrieslist): # <<<<<<<<<<<<<< + * c_lhss[i] = lhss[i] if lhss != None else 0.0 + * c_rhss[i] = rhss[i] if rhss != None else self.infinity() + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_2 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_entrieslist)) || PyTuple_CheckExact(__pyx_v_entrieslist)) { + __pyx_t_3 = __pyx_v_entrieslist; __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_entrieslist); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 201, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 201, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 201, __pyx_L1_error) + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 201, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(2, 201, __pyx_L1_error) + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } + } else { + __pyx_t_6 = __pyx_t_5(__pyx_t_3); + if (unlikely(!__pyx_t_6)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 201, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_6); + } + __Pyx_XDECREF_SET(__pyx_v_entries, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "src/pyscipopt/lp.pxi":202 + * tmp = 0 + * for i,entries in enumerate(entrieslist): + * c_lhss[i] = lhss[i] if lhss != None else 0.0 # <<<<<<<<<<<<<< + * c_rhss[i] = rhss[i] if rhss != None else self.infinity() + * c_beg[i] = tmp + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_lhss, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 202, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 202, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_lhss, __pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 202, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = __pyx_t_9; + } else { + __pyx_t_7 = 0.0; + } + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 202, __pyx_L1_error) + (__pyx_v_c_lhss[__pyx_t_10]) = __pyx_t_7; + + /* "src/pyscipopt/lp.pxi":203 + * for i,entries in enumerate(entrieslist): + * c_lhss[i] = lhss[i] if lhss != None else 0.0 + * c_rhss[i] = rhss[i] if rhss != None else self.infinity() # <<<<<<<<<<<<<< + * c_beg[i] = tmp + * + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_rhss, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 203, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(2, 203, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_8) { + __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_rhss, __pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 203, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = __pyx_t_9; + } else { + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_infinity); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = NULL; + __pyx_t_13 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_11, function); + __pyx_t_13 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+1-__pyx_t_13, 0+__pyx_t_13); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 203, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = __pyx_t_9; + } + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 203, __pyx_L1_error) + (__pyx_v_c_rhss[__pyx_t_10]) = __pyx_t_7; + + /* "src/pyscipopt/lp.pxi":204 + * c_lhss[i] = lhss[i] if lhss != None else 0.0 + * c_rhss[i] = rhss[i] if rhss != None else self.infinity() + * c_beg[i] = tmp # <<<<<<<<<<<<<< + * + * for entry in entries: + */ + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_tmp); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 204, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 204, __pyx_L1_error) + (__pyx_v_c_beg[__pyx_t_10]) = __pyx_t_13; + + /* "src/pyscipopt/lp.pxi":206 + * c_beg[i] = tmp + * + * for entry in entries: # <<<<<<<<<<<<<< + * c_inds[tmp] = entry[0] + * c_coefs[tmp] = entry[1] + */ + if (likely(PyList_CheckExact(__pyx_v_entries)) || PyTuple_CheckExact(__pyx_v_entries)) { + __pyx_t_6 = __pyx_v_entries; __Pyx_INCREF(__pyx_t_6); + __pyx_t_10 = 0; + __pyx_t_14 = NULL; + } else { + __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_v_entries); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_14 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 206, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_14)) { + if (likely(PyList_CheckExact(__pyx_t_6))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_6); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 206, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_11); __pyx_t_10++; if (unlikely((0 < 0))) __PYX_ERR(2, 206, __pyx_L1_error) + #else + __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_6); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 206, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_11); __pyx_t_10++; if (unlikely((0 < 0))) __PYX_ERR(2, 206, __pyx_L1_error) + #else + __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + #endif + } + } else { + __pyx_t_11 = __pyx_t_14(__pyx_t_6); + if (unlikely(!__pyx_t_11)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 206, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_11); + } + __Pyx_XDECREF_SET(__pyx_v_entry, __pyx_t_11); + __pyx_t_11 = 0; + + /* "src/pyscipopt/lp.pxi":207 + * + * for entry in entries: + * c_inds[tmp] = entry[0] # <<<<<<<<<<<<<< + * c_coefs[tmp] = entry[1] + * tmp += 1 + */ + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_entry, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_15 = __Pyx_PyIndex_AsSsize_t(__pyx_v_tmp); if (unlikely((__pyx_t_15 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 207, __pyx_L1_error) + (__pyx_v_c_inds[__pyx_t_15]) = __pyx_t_13; + + /* "src/pyscipopt/lp.pxi":208 + * for entry in entries: + * c_inds[tmp] = entry[0] + * c_coefs[tmp] = entry[1] # <<<<<<<<<<<<<< + * tmp += 1 + * + */ + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_entry, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_11); if (unlikely((__pyx_t_7 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 208, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_15 = __Pyx_PyIndex_AsSsize_t(__pyx_v_tmp); if (unlikely((__pyx_t_15 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 208, __pyx_L1_error) + (__pyx_v_c_coefs[__pyx_t_15]) = __pyx_t_7; + + /* "src/pyscipopt/lp.pxi":209 + * c_inds[tmp] = entry[0] + * c_coefs[tmp] = entry[1] + * tmp += 1 # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPlpiAddRows(self.lpi, nrows, c_lhss, c_rhss, NULL, nnonz, c_beg, c_inds, c_coefs)) + */ + __pyx_t_11 = __Pyx_PyInt_AddObjC(__pyx_v_tmp, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(2, 209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF_SET(__pyx_v_tmp, __pyx_t_11); + __pyx_t_11 = 0; + + /* "src/pyscipopt/lp.pxi":206 + * c_beg[i] = tmp + * + * for entry in entries: # <<<<<<<<<<<<<< + * c_inds[tmp] = entry[0] + * c_coefs[tmp] = entry[1] + */ + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "src/pyscipopt/lp.pxi":201 + * + * tmp = 0 + * for i,entries in enumerate(entrieslist): # <<<<<<<<<<<<<< + * c_lhss[i] = lhss[i] if lhss != None else 0.0 + * c_rhss[i] = rhss[i] if rhss != None else self.infinity() + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":211 + * tmp += 1 + * + * PY_SCIP_CALL(SCIPlpiAddRows(self.lpi, nrows, c_lhss, c_rhss, NULL, nnonz, c_beg, c_inds, c_coefs)) # <<<<<<<<<<<<<< + * + * free(c_beg) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_v_nrows); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 211, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_v_nnonz); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 211, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiAddRows(__pyx_v_self->lpi, __pyx_t_13, __pyx_v_c_lhss, __pyx_v_c_rhss, NULL, __pyx_t_16, __pyx_v_c_beg, __pyx_v_c_inds, __pyx_v_c_coefs)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_11 = NULL; + __pyx_t_16 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_16 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_16, 1+__pyx_t_16); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":213 + * PY_SCIP_CALL(SCIPlpiAddRows(self.lpi, nrows, c_lhss, c_rhss, NULL, nnonz, c_beg, c_inds, c_coefs)) + * + * free(c_beg) # <<<<<<<<<<<<<< + * free(c_inds) + * free(c_coefs) + */ + free(__pyx_v_c_beg); + + /* "src/pyscipopt/lp.pxi":214 + * + * free(c_beg) + * free(c_inds) # <<<<<<<<<<<<<< + * free(c_coefs) + * free(c_lhss) + */ + free(__pyx_v_c_inds); + + /* "src/pyscipopt/lp.pxi":215 + * free(c_beg) + * free(c_inds) + * free(c_coefs) # <<<<<<<<<<<<<< + * free(c_lhss) + * free(c_rhss) + */ + free(__pyx_v_c_coefs); + + /* "src/pyscipopt/lp.pxi":216 + * free(c_inds) + * free(c_coefs) + * free(c_lhss) # <<<<<<<<<<<<<< + * free(c_rhss) + * + */ + free(__pyx_v_c_lhss); + + /* "src/pyscipopt/lp.pxi":217 + * free(c_coefs) + * free(c_lhss) + * free(c_rhss) # <<<<<<<<<<<<<< + * + * def delRows(self, firstrow, lastrow): + */ + free(__pyx_v_c_rhss); + + /* "src/pyscipopt/lp.pxi":183 + * free(c_inds) + * + * def addRows(self, entrieslist, lhss = None, rhss = None): # <<<<<<<<<<<<<< + * """Adds multiple rows to the LP. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("pyscipopt.scip.LP.addRows", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nrows); + __Pyx_XDECREF(__pyx_v_nnonz); + __Pyx_XDECREF(__pyx_v_tmp); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_entries); + __Pyx_XDECREF(__pyx_v_entry); + __Pyx_XDECREF(__pyx_gb_9pyscipopt_4scip_2LP_7addRows_2generator3); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":219 + * free(c_rhss) + * + * def delRows(self, firstrow, lastrow): # <<<<<<<<<<<<<< + * """Deletes a range of rows from the LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_25delRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_24delRows, "LP.delRows(self, firstrow, lastrow)\nDeletes a range of rows from the LP.\n\n Keyword arguments:\n firstrow -- first row to delete\n lastrow -- last row to delete\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_25delRows = {"delRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_25delRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_24delRows}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_25delRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_firstrow = 0; + PyObject *__pyx_v_lastrow = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("delRows (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_firstrow,&__pyx_n_s_lastrow,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_firstrow)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 219, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lastrow)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 219, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("delRows", 1, 2, 2, 1); __PYX_ERR(2, 219, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delRows") < 0)) __PYX_ERR(2, 219, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_firstrow = values[0]; + __pyx_v_lastrow = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delRows", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 219, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.delRows", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_24delRows(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_firstrow, __pyx_v_lastrow); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_24delRows(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_firstrow, PyObject *__pyx_v_lastrow) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("delRows", 1); + + /* "src/pyscipopt/lp.pxi":226 + * lastrow -- last row to delete + * """ + * PY_SCIP_CALL(SCIPlpiDelRows(self.lpi, firstrow, lastrow)) # <<<<<<<<<<<<<< + * + * def getBounds(self, firstcol = 0, lastcol = None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_firstrow); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 226, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_lastrow); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 226, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiDelRows(__pyx_v_self->lpi, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":219 + * free(c_rhss) + * + * def delRows(self, firstrow, lastrow): # <<<<<<<<<<<<<< + * """Deletes a range of rows from the LP. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.delRows", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":228 + * PY_SCIP_CALL(SCIPlpiDelRows(self.lpi, firstrow, lastrow)) + * + * def getBounds(self, firstcol = 0, lastcol = None): # <<<<<<<<<<<<<< + * """Returns all lower and upper bounds for a range of columns. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_27getBounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_26getBounds, "LP.getBounds(self, firstcol=0, lastcol=None)\nReturns all lower and upper bounds for a range of columns.\n\n Keyword arguments:\n firstcol -- first column (default 0)\n lastcol -- last column (default ncols - 1)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_27getBounds = {"getBounds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_27getBounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_26getBounds}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_27getBounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_firstcol = 0; + PyObject *__pyx_v_lastcol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBounds (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_firstcol,&__pyx_n_s_lastcol,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_0)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_firstcol); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 228, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lastcol); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 228, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getBounds") < 0)) __PYX_ERR(2, 228, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_firstcol = values[0]; + __pyx_v_lastcol = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getBounds", 0, 0, 2, __pyx_nargs); __PYX_ERR(2, 228, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.getBounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_26getBounds(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_firstcol, __pyx_v_lastcol); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_26getBounds(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_firstcol, PyObject *__pyx_v_lastcol) { + PyObject *__pyx_v_ncols = NULL; + SCIP_Real *__pyx_v_c_lbs; + SCIP_Real *__pyx_v_c_ubs; + PyObject *__pyx_v_lbs = NULL; + PyObject *__pyx_v_ubs = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + size_t __pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + Py_ssize_t __pyx_t_11; + int __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBounds", 0); + __Pyx_INCREF(__pyx_v_lastcol); + + /* "src/pyscipopt/lp.pxi":235 + * lastcol -- last column (default ncols - 1) + * """ + * lastcol = lastcol if lastcol != None else self.ncols() - 1 # <<<<<<<<<<<<<< + * + * if firstcol > lastcol: + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_lastcol, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 235, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 235, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_3) { + __Pyx_INCREF(__pyx_v_lastcol); + __pyx_t_1 = __pyx_v_lastcol; + } else { + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncols); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + } + __Pyx_DECREF_SET(__pyx_v_lastcol, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":237 + * lastcol = lastcol if lastcol != None else self.ncols() - 1 + * + * if firstcol > lastcol: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_firstcol, __pyx_v_lastcol, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 237, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 237, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { + + /* "src/pyscipopt/lp.pxi":238 + * + * if firstcol > lastcol: + * return None # <<<<<<<<<<<<<< + * + * ncols = lastcol - firstcol + 1 + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":237 + * lastcol = lastcol if lastcol != None else self.ncols() - 1 + * + * if firstcol > lastcol: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "src/pyscipopt/lp.pxi":240 + * return None + * + * ncols = lastcol - firstcol + 1 # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) + */ + __pyx_t_1 = PyNumber_Subtract(__pyx_v_lastcol, __pyx_v_firstcol); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_ncols = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":241 + * + * ncols = lastcol - firstcol + 1 + * cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetBounds(self.lpi, firstcol, lastcol, c_lbs, c_ubs)) + */ + __pyx_t_4 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_1); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_c_lbs = ((SCIP_Real *)malloc(__pyx_t_7)); + + /* "src/pyscipopt/lp.pxi":242 + * ncols = lastcol - firstcol + 1 + * cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetBounds(self.lpi, firstcol, lastcol, c_lbs, c_ubs)) + * + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_c_ubs = ((SCIP_Real *)malloc(__pyx_t_7)); + + /* "src/pyscipopt/lp.pxi":243 + * cdef SCIP_Real* c_lbs = malloc(ncols * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_ubs = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetBounds(self.lpi, firstcol, lastcol, c_lbs, c_ubs)) # <<<<<<<<<<<<<< + * + * lbs = [] + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_firstcol); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 243, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_lastcol); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 243, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetBounds(__pyx_v_self->lpi, __pyx_t_6, __pyx_t_8, __pyx_v_c_lbs, __pyx_v_c_ubs)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_2}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":245 + * PY_SCIP_CALL(SCIPlpiGetBounds(self.lpi, firstcol, lastcol, c_lbs, c_ubs)) + * + * lbs = [] # <<<<<<<<<<<<<< + * ubs = [] + * + */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_lbs = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":246 + * + * lbs = [] + * ubs = [] # <<<<<<<<<<<<<< + * + * for i in range(ncols): + */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_ubs = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":248 + * ubs = [] + * + * for i in range(ncols): # <<<<<<<<<<<<<< + * lbs.append(c_lbs[i]) + * ubs.append(c_ubs[i]) + */ + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_v_ncols); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { + __pyx_t_1 = __pyx_t_4; __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 248, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 248, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(2, 248, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 248, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(2, 248, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_10(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 248, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":249 + * + * for i in range(ncols): + * lbs.append(c_lbs[i]) # <<<<<<<<<<<<<< + * ubs.append(c_ubs[i]) + * + */ + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 249, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_c_lbs[__pyx_t_11])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_lbs, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(2, 249, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":250 + * for i in range(ncols): + * lbs.append(c_lbs[i]) + * ubs.append(c_ubs[i]) # <<<<<<<<<<<<<< + * + * free(c_ubs) + */ + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 250, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_c_ubs[__pyx_t_11])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ubs, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(2, 250, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":248 + * ubs = [] + * + * for i in range(ncols): # <<<<<<<<<<<<<< + * lbs.append(c_lbs[i]) + * ubs.append(c_ubs[i]) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":252 + * ubs.append(c_ubs[i]) + * + * free(c_ubs) # <<<<<<<<<<<<<< + * free(c_lbs) + * + */ + free(__pyx_v_c_ubs); + + /* "src/pyscipopt/lp.pxi":253 + * + * free(c_ubs) + * free(c_lbs) # <<<<<<<<<<<<<< + * + * return lbs, ubs + */ + free(__pyx_v_c_lbs); + + /* "src/pyscipopt/lp.pxi":255 + * free(c_lbs) + * + * return lbs, ubs # <<<<<<<<<<<<<< + * + * def getSides(self, firstrow = 0, lastrow = None): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_lbs); + __Pyx_GIVEREF(__pyx_v_lbs); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_lbs)) __PYX_ERR(2, 255, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_ubs); + __Pyx_GIVEREF(__pyx_v_ubs); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_ubs)) __PYX_ERR(2, 255, __pyx_L1_error); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":228 + * PY_SCIP_CALL(SCIPlpiDelRows(self.lpi, firstrow, lastrow)) + * + * def getBounds(self, firstcol = 0, lastcol = None): # <<<<<<<<<<<<<< + * """Returns all lower and upper bounds for a range of columns. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.LP.getBounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ncols); + __Pyx_XDECREF(__pyx_v_lbs); + __Pyx_XDECREF(__pyx_v_ubs); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_lastcol); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":257 + * return lbs, ubs + * + * def getSides(self, firstrow = 0, lastrow = None): # <<<<<<<<<<<<<< + * """Returns all left- and right-hand sides for a range of rows. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_29getSides(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_28getSides, "LP.getSides(self, firstrow=0, lastrow=None)\nReturns all left- and right-hand sides for a range of rows.\n\n Keyword arguments:\n firstrow -- first row (default 0)\n lastrow -- last row (default nrows - 1)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_29getSides = {"getSides", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_29getSides, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_28getSides}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_29getSides(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_firstrow = 0; + PyObject *__pyx_v_lastrow = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getSides (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_firstrow,&__pyx_n_s_lastrow,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_0)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_firstrow); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 257, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lastrow); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 257, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getSides") < 0)) __PYX_ERR(2, 257, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_firstrow = values[0]; + __pyx_v_lastrow = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getSides", 0, 0, 2, __pyx_nargs); __PYX_ERR(2, 257, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.getSides", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_28getSides(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_firstrow, __pyx_v_lastrow); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_28getSides(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_firstrow, PyObject *__pyx_v_lastrow) { + PyObject *__pyx_v_nrows = NULL; + SCIP_Real *__pyx_v_c_lhss; + SCIP_Real *__pyx_v_c_rhss; + PyObject *__pyx_v_lhss = NULL; + PyObject *__pyx_v_rhss = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + size_t __pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + Py_ssize_t __pyx_t_11; + int __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getSides", 0); + __Pyx_INCREF(__pyx_v_lastrow); + + /* "src/pyscipopt/lp.pxi":264 + * lastrow -- last row (default nrows - 1) + * """ + * lastrow = lastrow if lastrow != None else self.nrows() - 1 # <<<<<<<<<<<<<< + * + * if firstrow > lastrow: + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_lastrow, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 264, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 264, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_3) { + __Pyx_INCREF(__pyx_v_lastrow); + __pyx_t_1 = __pyx_v_lastrow; + } else { + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_nrows); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + } + __Pyx_DECREF_SET(__pyx_v_lastrow, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":266 + * lastrow = lastrow if lastrow != None else self.nrows() - 1 + * + * if firstrow > lastrow: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_firstrow, __pyx_v_lastrow, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 266, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(2, 266, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_3) { + + /* "src/pyscipopt/lp.pxi":267 + * + * if firstrow > lastrow: + * return None # <<<<<<<<<<<<<< + * + * nrows = lastrow - firstrow + 1 + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":266 + * lastrow = lastrow if lastrow != None else self.nrows() - 1 + * + * if firstrow > lastrow: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "src/pyscipopt/lp.pxi":269 + * return None + * + * nrows = lastrow - firstrow + 1 # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) + */ + __pyx_t_1 = PyNumber_Subtract(__pyx_v_lastrow, __pyx_v_firstrow); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_nrows = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":270 + * + * nrows = lastrow - firstrow + 1 + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSides(self.lpi, firstrow, lastrow, c_lhss, c_rhss)) + */ + __pyx_t_4 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyNumber_Multiply(__pyx_v_nrows, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_1); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_c_lhss = ((SCIP_Real *)malloc(__pyx_t_7)); + + /* "src/pyscipopt/lp.pxi":271 + * nrows = lastrow - firstrow + 1 + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetSides(self.lpi, firstrow, lastrow, c_lhss, c_rhss)) + * + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyNumber_Multiply(__pyx_v_nrows, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_7 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_7 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 271, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_c_rhss = ((SCIP_Real *)malloc(__pyx_t_7)); + + /* "src/pyscipopt/lp.pxi":272 + * cdef SCIP_Real* c_lhss = malloc(nrows * sizeof(SCIP_Real)) + * cdef SCIP_Real* c_rhss = malloc(nrows * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSides(self.lpi, firstrow, lastrow, c_lhss, c_rhss)) # <<<<<<<<<<<<<< + * + * lhss = [] + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_firstrow); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 272, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_lastrow); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 272, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetSides(__pyx_v_self->lpi, __pyx_t_6, __pyx_t_8, __pyx_v_c_lhss, __pyx_v_c_rhss)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_2}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":274 + * PY_SCIP_CALL(SCIPlpiGetSides(self.lpi, firstrow, lastrow, c_lhss, c_rhss)) + * + * lhss = [] # <<<<<<<<<<<<<< + * rhss = [] + * + */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_lhss = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":275 + * + * lhss = [] + * rhss = [] # <<<<<<<<<<<<<< + * + * for i in range(firstrow, lastrow + 1): + */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_rhss = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":277 + * rhss = [] + * + * for i in range(firstrow, lastrow + 1): # <<<<<<<<<<<<<< + * lhss.append(c_lhss[i]) + * rhss.append(c_rhss[i]) + */ + __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_v_lastrow, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_firstrow); + __Pyx_GIVEREF(__pyx_v_firstrow); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_firstrow)) __PYX_ERR(2, 277, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4)) __PYX_ERR(2, 277, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { + __pyx_t_1 = __pyx_t_4; __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 277, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 277, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(2, 277, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 277, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(2, 277, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_10(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 277, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":278 + * + * for i in range(firstrow, lastrow + 1): + * lhss.append(c_lhss[i]) # <<<<<<<<<<<<<< + * rhss.append(c_rhss[i]) + * + */ + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 278, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_c_lhss[__pyx_t_11])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_lhss, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(2, 278, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":279 + * for i in range(firstrow, lastrow + 1): + * lhss.append(c_lhss[i]) + * rhss.append(c_rhss[i]) # <<<<<<<<<<<<<< + * + * free(c_rhss) + */ + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 279, __pyx_L1_error) + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_c_rhss[__pyx_t_11])); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_rhss, __pyx_t_4); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(2, 279, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/lp.pxi":277 + * rhss = [] + * + * for i in range(firstrow, lastrow + 1): # <<<<<<<<<<<<<< + * lhss.append(c_lhss[i]) + * rhss.append(c_rhss[i]) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":281 + * rhss.append(c_rhss[i]) + * + * free(c_rhss) # <<<<<<<<<<<<<< + * free(c_lhss) + * + */ + free(__pyx_v_c_rhss); + + /* "src/pyscipopt/lp.pxi":282 + * + * free(c_rhss) + * free(c_lhss) # <<<<<<<<<<<<<< + * + * return lhss, rhss + */ + free(__pyx_v_c_lhss); + + /* "src/pyscipopt/lp.pxi":284 + * free(c_lhss) + * + * return lhss, rhss # <<<<<<<<<<<<<< + * + * def chgObj(self, col, obj): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_lhss); + __Pyx_GIVEREF(__pyx_v_lhss); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_lhss)) __PYX_ERR(2, 284, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_rhss); + __Pyx_GIVEREF(__pyx_v_rhss); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_rhss)) __PYX_ERR(2, 284, __pyx_L1_error); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":257 + * return lbs, ubs + * + * def getSides(self, firstrow = 0, lastrow = None): # <<<<<<<<<<<<<< + * """Returns all left- and right-hand sides for a range of rows. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.LP.getSides", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nrows); + __Pyx_XDECREF(__pyx_v_lhss); + __Pyx_XDECREF(__pyx_v_rhss); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_lastrow); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":286 + * return lhss, rhss + * + * def chgObj(self, col, obj): # <<<<<<<<<<<<<< + * """Changes objective coefficient of a single column. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_31chgObj(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_30chgObj, "LP.chgObj(self, col, obj)\nChanges objective coefficient of a single column.\n\n Keyword arguments:\n col -- column to change\n obj -- new objective coefficient\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_31chgObj = {"chgObj", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_31chgObj, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_30chgObj}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_31chgObj(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_col = 0; + PyObject *__pyx_v_obj = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgObj (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_col,&__pyx_n_s_obj,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_col)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 286, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 286, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgObj", 1, 2, 2, 1); __PYX_ERR(2, 286, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgObj") < 0)) __PYX_ERR(2, 286, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_col = values[0]; + __pyx_v_obj = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgObj", 1, 2, 2, __pyx_nargs); __PYX_ERR(2, 286, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.chgObj", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_30chgObj(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_col, __pyx_v_obj); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_30chgObj(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_col, PyObject *__pyx_v_obj) { + int __pyx_v_c_col; + SCIP_Real __pyx_v_c_obj; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgObj", 1); + + /* "src/pyscipopt/lp.pxi":293 + * obj -- new objective coefficient + * """ + * cdef int c_col = col # <<<<<<<<<<<<<< + * cdef SCIP_Real c_obj = obj + * PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj)) + */ + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_col); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 293, __pyx_L1_error) + __pyx_v_c_col = __pyx_t_1; + + /* "src/pyscipopt/lp.pxi":294 + * """ + * cdef int c_col = col + * cdef SCIP_Real c_obj = obj # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj)) + * + */ + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_obj); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 294, __pyx_L1_error) + __pyx_v_c_obj = __pyx_t_2; + + /* "src/pyscipopt/lp.pxi":295 + * cdef int c_col = col + * cdef SCIP_Real c_obj = obj + * PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj)) # <<<<<<<<<<<<<< + * + * def chgCoef(self, row, col, newval): + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiChgObj(__pyx_v_self->lpi, 1, (&__pyx_v_c_col), (&__pyx_v_c_obj))); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_1 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_1 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_1, 1+__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":286 + * return lhss, rhss + * + * def chgObj(self, col, obj): # <<<<<<<<<<<<<< + * """Changes objective coefficient of a single column. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.chgObj", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":297 + * PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj)) + * + * def chgCoef(self, row, col, newval): # <<<<<<<<<<<<<< + * """Changes a single coefficient in the LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_33chgCoef(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_32chgCoef, "LP.chgCoef(self, row, col, newval)\nChanges a single coefficient in the LP.\n\n Keyword arguments:\n row -- row to change\n col -- column to change\n newval -- new coefficient\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_33chgCoef = {"chgCoef", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_33chgCoef, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_32chgCoef}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_33chgCoef(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_row = 0; + PyObject *__pyx_v_col = 0; + PyObject *__pyx_v_newval = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgCoef (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_col,&__pyx_n_s_newval,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 297, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_col)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 297, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgCoef", 1, 3, 3, 1); __PYX_ERR(2, 297, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newval)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 297, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgCoef", 1, 3, 3, 2); __PYX_ERR(2, 297, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgCoef") < 0)) __PYX_ERR(2, 297, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_row = values[0]; + __pyx_v_col = values[1]; + __pyx_v_newval = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgCoef", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 297, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.chgCoef", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_32chgCoef(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_row, __pyx_v_col, __pyx_v_newval); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_32chgCoef(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_row, PyObject *__pyx_v_col, PyObject *__pyx_v_newval) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + SCIP_Real __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgCoef", 1); + + /* "src/pyscipopt/lp.pxi":305 + * newval -- new coefficient + * """ + * PY_SCIP_CALL(SCIPlpiChgCoef(self.lpi, row, col, newval)) # <<<<<<<<<<<<<< + * + * def chgBound(self, col, lb, ub): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_row); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 305, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_col); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 305, __pyx_L1_error) + __pyx_t_5 = __pyx_PyFloat_AsDouble(__pyx_v_newval); if (unlikely((__pyx_t_5 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 305, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiChgCoef(__pyx_v_self->lpi, __pyx_t_3, __pyx_t_4, __pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":297 + * PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj)) + * + * def chgCoef(self, row, col, newval): # <<<<<<<<<<<<<< + * """Changes a single coefficient in the LP. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.LP.chgCoef", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":307 + * PY_SCIP_CALL(SCIPlpiChgCoef(self.lpi, row, col, newval)) + * + * def chgBound(self, col, lb, ub): # <<<<<<<<<<<<<< + * """Changes the lower and upper bound of a single column. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_35chgBound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_34chgBound, "LP.chgBound(self, col, lb, ub)\nChanges the lower and upper bound of a single column.\n\n Keyword arguments:\n col -- column to change\n lb -- new lower bound\n ub -- new upper bound\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_35chgBound = {"chgBound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_35chgBound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_34chgBound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_35chgBound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_col = 0; + PyObject *__pyx_v_lb = 0; + PyObject *__pyx_v_ub = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgBound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_col,&__pyx_n_s_lb,&__pyx_n_s_ub,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_col)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 307, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 307, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgBound", 1, 3, 3, 1); __PYX_ERR(2, 307, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 307, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgBound", 1, 3, 3, 2); __PYX_ERR(2, 307, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgBound") < 0)) __PYX_ERR(2, 307, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_col = values[0]; + __pyx_v_lb = values[1]; + __pyx_v_ub = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgBound", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 307, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.chgBound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_34chgBound(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_col, __pyx_v_lb, __pyx_v_ub); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_34chgBound(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_col, PyObject *__pyx_v_lb, PyObject *__pyx_v_ub) { + int __pyx_v_c_col; + SCIP_Real __pyx_v_c_lb; + SCIP_Real __pyx_v_c_ub; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgBound", 1); + + /* "src/pyscipopt/lp.pxi":315 + * ub -- new upper bound + * """ + * cdef int c_col = col # <<<<<<<<<<<<<< + * cdef SCIP_Real c_lb = lb + * cdef SCIP_Real c_ub = ub + */ + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_col); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 315, __pyx_L1_error) + __pyx_v_c_col = __pyx_t_1; + + /* "src/pyscipopt/lp.pxi":316 + * """ + * cdef int c_col = col + * cdef SCIP_Real c_lb = lb # <<<<<<<<<<<<<< + * cdef SCIP_Real c_ub = ub + * PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub)) + */ + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 316, __pyx_L1_error) + __pyx_v_c_lb = __pyx_t_2; + + /* "src/pyscipopt/lp.pxi":317 + * cdef int c_col = col + * cdef SCIP_Real c_lb = lb + * cdef SCIP_Real c_ub = ub # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub)) + * + */ + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 317, __pyx_L1_error) + __pyx_v_c_ub = __pyx_t_2; + + /* "src/pyscipopt/lp.pxi":318 + * cdef SCIP_Real c_lb = lb + * cdef SCIP_Real c_ub = ub + * PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub)) # <<<<<<<<<<<<<< + * + * def chgSide(self, row, lhs, rhs): + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiChgBounds(__pyx_v_self->lpi, 1, (&__pyx_v_c_col), (&__pyx_v_c_lb), (&__pyx_v_c_ub))); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_1 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_1 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_1, 1+__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":307 + * PY_SCIP_CALL(SCIPlpiChgCoef(self.lpi, row, col, newval)) + * + * def chgBound(self, col, lb, ub): # <<<<<<<<<<<<<< + * """Changes the lower and upper bound of a single column. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.chgBound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":320 + * PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub)) + * + * def chgSide(self, row, lhs, rhs): # <<<<<<<<<<<<<< + * """Changes the left- and right-hand side of a single row. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_37chgSide(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_36chgSide, "LP.chgSide(self, row, lhs, rhs)\nChanges the left- and right-hand side of a single row.\n\n Keyword arguments:\n row -- row to change\n lhs -- new left-hand side\n rhs -- new right-hand side\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_37chgSide = {"chgSide", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_37chgSide, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_36chgSide}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_37chgSide(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_row = 0; + PyObject *__pyx_v_lhs = 0; + PyObject *__pyx_v_rhs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgSide (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_lhs,&__pyx_n_s_rhs,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 320, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lhs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 320, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgSide", 1, 3, 3, 1); __PYX_ERR(2, 320, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rhs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 320, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgSide", 1, 3, 3, 2); __PYX_ERR(2, 320, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgSide") < 0)) __PYX_ERR(2, 320, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_row = values[0]; + __pyx_v_lhs = values[1]; + __pyx_v_rhs = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgSide", 1, 3, 3, __pyx_nargs); __PYX_ERR(2, 320, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.chgSide", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_36chgSide(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_row, __pyx_v_lhs, __pyx_v_rhs); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_36chgSide(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_row, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs) { + int __pyx_v_c_row; + SCIP_Real __pyx_v_c_lhs; + SCIP_Real __pyx_v_c_rhs; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgSide", 1); + + /* "src/pyscipopt/lp.pxi":328 + * rhs -- new right-hand side + * """ + * cdef int c_row = row # <<<<<<<<<<<<<< + * cdef SCIP_Real c_lhs = lhs + * cdef SCIP_Real c_rhs = rhs + */ + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_row); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 328, __pyx_L1_error) + __pyx_v_c_row = __pyx_t_1; + + /* "src/pyscipopt/lp.pxi":329 + * """ + * cdef int c_row = row + * cdef SCIP_Real c_lhs = lhs # <<<<<<<<<<<<<< + * cdef SCIP_Real c_rhs = rhs + * PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs)) + */ + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_lhs); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 329, __pyx_L1_error) + __pyx_v_c_lhs = __pyx_t_2; + + /* "src/pyscipopt/lp.pxi":330 + * cdef int c_row = row + * cdef SCIP_Real c_lhs = lhs + * cdef SCIP_Real c_rhs = rhs # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs)) + * + */ + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_rhs); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(2, 330, __pyx_L1_error) + __pyx_v_c_rhs = __pyx_t_2; + + /* "src/pyscipopt/lp.pxi":331 + * cdef SCIP_Real c_lhs = lhs + * cdef SCIP_Real c_rhs = rhs + * PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs)) # <<<<<<<<<<<<<< + * + * def clear(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiChgSides(__pyx_v_self->lpi, 1, (&__pyx_v_c_row), (&__pyx_v_c_lhs), (&__pyx_v_c_rhs))); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_1 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_1 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_1, 1+__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":320 + * PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub)) + * + * def chgSide(self, row, lhs, rhs): # <<<<<<<<<<<<<< + * """Changes the left- and right-hand side of a single row. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.chgSide", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":333 + * PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs)) + * + * def clear(self): # <<<<<<<<<<<<<< + * """Clears the whole LP.""" + * PY_SCIP_CALL(SCIPlpiClear(self.lpi)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_39clear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_38clear, "LP.clear(self)\nClears the whole LP."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_39clear = {"clear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_39clear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_38clear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_39clear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("clear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("clear", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "clear", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_38clear(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_38clear(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("clear", 1); + + /* "src/pyscipopt/lp.pxi":335 + * def clear(self): + * """Clears the whole LP.""" + * PY_SCIP_CALL(SCIPlpiClear(self.lpi)) # <<<<<<<<<<<<<< + * + * def nrows(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiClear(__pyx_v_self->lpi)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":333 + * PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs)) + * + * def clear(self): # <<<<<<<<<<<<<< + * """Clears the whole LP.""" + * PY_SCIP_CALL(SCIPlpiClear(self.lpi)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.LP.clear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":337 + * PY_SCIP_CALL(SCIPlpiClear(self.lpi)) + * + * def nrows(self): # <<<<<<<<<<<<<< + * """Returns the number of rows.""" + * cdef int nrows + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_41nrows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_40nrows, "LP.nrows(self)\nReturns the number of rows."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_41nrows = {"nrows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_41nrows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_40nrows}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_41nrows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nrows (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("nrows", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "nrows", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_40nrows(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_40nrows(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + int __pyx_v_nrows; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("nrows", 1); + + /* "src/pyscipopt/lp.pxi":340 + * """Returns the number of rows.""" + * cdef int nrows + * PY_SCIP_CALL(SCIPlpiGetNRows(self.lpi, &nrows)) # <<<<<<<<<<<<<< + * return nrows + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetNRows(__pyx_v_self->lpi, (&__pyx_v_nrows))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":341 + * cdef int nrows + * PY_SCIP_CALL(SCIPlpiGetNRows(self.lpi, &nrows)) + * return nrows # <<<<<<<<<<<<<< + * + * def ncols(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_nrows); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":337 + * PY_SCIP_CALL(SCIPlpiClear(self.lpi)) + * + * def nrows(self): # <<<<<<<<<<<<<< + * """Returns the number of rows.""" + * cdef int nrows + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.LP.nrows", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":343 + * return nrows + * + * def ncols(self): # <<<<<<<<<<<<<< + * """Returns the number of columns.""" + * cdef int ncols + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_43ncols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_42ncols, "LP.ncols(self)\nReturns the number of columns."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_43ncols = {"ncols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_43ncols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_42ncols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_43ncols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ncols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("ncols", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "ncols", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_42ncols(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_42ncols(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + int __pyx_v_ncols; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ncols", 1); + + /* "src/pyscipopt/lp.pxi":346 + * """Returns the number of columns.""" + * cdef int ncols + * PY_SCIP_CALL(SCIPlpiGetNCols(self.lpi, &ncols)) # <<<<<<<<<<<<<< + * return ncols + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetNCols(__pyx_v_self->lpi, (&__pyx_v_ncols))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":347 + * cdef int ncols + * PY_SCIP_CALL(SCIPlpiGetNCols(self.lpi, &ncols)) + * return ncols # <<<<<<<<<<<<<< + * + * def solve(self, dual=True): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ncols); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":343 + * return nrows + * + * def ncols(self): # <<<<<<<<<<<<<< + * """Returns the number of columns.""" + * cdef int ncols + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.LP.ncols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":349 + * return ncols + * + * def solve(self, dual=True): # <<<<<<<<<<<<<< + * """Solves the current LP. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_45solve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_44solve, "LP.solve(self, dual=True)\nSolves the current LP.\n\n Keyword arguments:\n dual -- use the dual or primal Simplex method (default: dual)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_45solve = {"solve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_45solve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_44solve}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_45solve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_dual = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solve (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dual,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dual); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(2, 349, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "solve") < 0)) __PYX_ERR(2, 349, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_dual = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("solve", 0, 0, 1, __pyx_nargs); __PYX_ERR(2, 349, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.solve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_44solve(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v_dual); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_44solve(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, PyObject *__pyx_v_dual) { + SCIP_Real __pyx_v_objval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve", 1); + + /* "src/pyscipopt/lp.pxi":355 + * dual -- use the dual or primal Simplex method (default: dual) + * """ + * if dual: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiSolveDual(self.lpi)) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_dual); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(2, 355, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/lp.pxi":356 + * """ + * if dual: + * PY_SCIP_CALL(SCIPlpiSolveDual(self.lpi)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPlpiSolvePrimal(self.lpi)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiSolveDual(__pyx_v_self->lpi)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":355 + * dual -- use the dual or primal Simplex method (default: dual) + * """ + * if dual: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiSolveDual(self.lpi)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/lp.pxi":358 + * PY_SCIP_CALL(SCIPlpiSolveDual(self.lpi)) + * else: + * PY_SCIP_CALL(SCIPlpiSolvePrimal(self.lpi)) # <<<<<<<<<<<<<< + * + * cdef SCIP_Real objval + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiSolvePrimal(__pyx_v_self->lpi)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/lp.pxi":361 + * + * cdef SCIP_Real objval + * PY_SCIP_CALL(SCIPlpiGetObjval(self.lpi, &objval)) # <<<<<<<<<<<<<< + * return objval + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetObjval(__pyx_v_self->lpi, (&__pyx_v_objval))); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":362 + * cdef SCIP_Real objval + * PY_SCIP_CALL(SCIPlpiGetObjval(self.lpi, &objval)) + * return objval # <<<<<<<<<<<<<< + * + * def getPrimal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_objval); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":349 + * return ncols + * + * def solve(self, dual=True): # <<<<<<<<<<<<<< + * """Solves the current LP. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.LP.solve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":364 + * return objval + * + * def getPrimal(self): # <<<<<<<<<<<<<< + * """Returns the primal solution of the last LP solve.""" + * ncols = self.ncols() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_47getPrimal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_46getPrimal, "LP.getPrimal(self)\nReturns the primal solution of the last LP solve."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_47getPrimal = {"getPrimal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_47getPrimal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_46getPrimal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_47getPrimal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPrimal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getPrimal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPrimal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_46getPrimal(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_46getPrimal(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_v_ncols = NULL; + SCIP_Real *__pyx_v_c_primalsol; + PyObject *__pyx_v_primalsol = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getPrimal", 1); + + /* "src/pyscipopt/lp.pxi":366 + * def getPrimal(self): + * """Returns the primal solution of the last LP solve.""" + * ncols = self.ncols() # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_primalsol = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, c_primalsol, NULL, NULL, NULL)) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncols); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_ncols = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":367 + * """Returns the primal solution of the last LP solve.""" + * ncols = self.ncols() + * cdef SCIP_Real* c_primalsol = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, c_primalsol, NULL, NULL, NULL)) + * primalsol = [0.0] * ncols + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 367, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_primalsol = ((SCIP_Real *)malloc(__pyx_t_5)); + + /* "src/pyscipopt/lp.pxi":368 + * ncols = self.ncols() + * cdef SCIP_Real* c_primalsol = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, c_primalsol, NULL, NULL, NULL)) # <<<<<<<<<<<<<< + * primalsol = [0.0] * ncols + * for i in range(ncols): + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetSol(__pyx_v_self->lpi, NULL, __pyx_v_c_primalsol, NULL, NULL, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":369 + * cdef SCIP_Real* c_primalsol = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, c_primalsol, NULL, NULL, NULL)) + * primalsol = [0.0] * ncols # <<<<<<<<<<<<<< + * for i in range(ncols): + * primalsol[i] = c_primalsol[i] + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_float_0_0); + __Pyx_GIVEREF(__pyx_float_0_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_float_0_0)) __PYX_ERR(2, 369, __pyx_L1_error); + { PyObject* __pyx_temp = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_ncols); if (unlikely(!__pyx_temp)) __PYX_ERR(2, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_temp); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_temp; + } + __pyx_v_primalsol = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":370 + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, c_primalsol, NULL, NULL, NULL)) + * primalsol = [0.0] * ncols + * for i in range(ncols): # <<<<<<<<<<<<<< + * primalsol[i] = c_primalsol[i] + * free(c_primalsol) + */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_v_ncols); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 370, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 370, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(2, 370, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 370, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(2, 370, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_8(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 370, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":371 + * primalsol = [0.0] * ncols + * for i in range(ncols): + * primalsol[i] = c_primalsol[i] # <<<<<<<<<<<<<< + * free(c_primalsol) + * + */ + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 371, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble((__pyx_v_c_primalsol[__pyx_t_9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely((PyObject_SetItem(__pyx_v_primalsol, __pyx_v_i, __pyx_t_2) < 0))) __PYX_ERR(2, 371, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":370 + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, c_primalsol, NULL, NULL, NULL)) + * primalsol = [0.0] * ncols + * for i in range(ncols): # <<<<<<<<<<<<<< + * primalsol[i] = c_primalsol[i] + * free(c_primalsol) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":372 + * for i in range(ncols): + * primalsol[i] = c_primalsol[i] + * free(c_primalsol) # <<<<<<<<<<<<<< + * + * return primalsol + */ + free(__pyx_v_c_primalsol); + + /* "src/pyscipopt/lp.pxi":374 + * free(c_primalsol) + * + * return primalsol # <<<<<<<<<<<<<< + * + * def isPrimalFeasible(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_primalsol); + __pyx_r = __pyx_v_primalsol; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":364 + * return objval + * + * def getPrimal(self): # <<<<<<<<<<<<<< + * """Returns the primal solution of the last LP solve.""" + * ncols = self.ncols() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.getPrimal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ncols); + __Pyx_XDECREF(__pyx_v_primalsol); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":376 + * return primalsol + * + * def isPrimalFeasible(self): # <<<<<<<<<<<<<< + * """Returns True iff LP is proven to be primal feasible.""" + * return SCIPlpiIsPrimalFeasible(self.lpi) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_49isPrimalFeasible(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_48isPrimalFeasible, "LP.isPrimalFeasible(self)\nReturns True iff LP is proven to be primal feasible."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_49isPrimalFeasible = {"isPrimalFeasible", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_49isPrimalFeasible, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_48isPrimalFeasible}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_49isPrimalFeasible(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isPrimalFeasible (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isPrimalFeasible", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isPrimalFeasible", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_48isPrimalFeasible(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_48isPrimalFeasible(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isPrimalFeasible", 1); + + /* "src/pyscipopt/lp.pxi":378 + * def isPrimalFeasible(self): + * """Returns True iff LP is proven to be primal feasible.""" + * return SCIPlpiIsPrimalFeasible(self.lpi) # <<<<<<<<<<<<<< + * + * def getDual(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPlpiIsPrimalFeasible(__pyx_v_self->lpi)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":376 + * return primalsol + * + * def isPrimalFeasible(self): # <<<<<<<<<<<<<< + * """Returns True iff LP is proven to be primal feasible.""" + * return SCIPlpiIsPrimalFeasible(self.lpi) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.LP.isPrimalFeasible", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":380 + * return SCIPlpiIsPrimalFeasible(self.lpi) + * + * def getDual(self): # <<<<<<<<<<<<<< + * """Returns the dual solution of the last LP solve.""" + * nrows = self.nrows() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_51getDual(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_50getDual, "LP.getDual(self)\nReturns the dual solution of the last LP solve."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_51getDual = {"getDual", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_51getDual, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_50getDual}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_51getDual(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDual (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getDual", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDual", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_50getDual(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_50getDual(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_v_nrows = NULL; + SCIP_Real *__pyx_v_c_dualsol; + PyObject *__pyx_v_dualsol = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDual", 1); + + /* "src/pyscipopt/lp.pxi":382 + * def getDual(self): + * """Returns the dual solution of the last LP solve.""" + * nrows = self.nrows() # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_dualsol = malloc(nrows * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, c_dualsol, NULL, NULL)) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_nrows); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_nrows = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":383 + * """Returns the dual solution of the last LP solve.""" + * nrows = self.nrows() + * cdef SCIP_Real* c_dualsol = malloc(nrows * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, c_dualsol, NULL, NULL)) + * dualsol = [0.0] * nrows + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_nrows, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 383, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_dualsol = ((SCIP_Real *)malloc(__pyx_t_5)); + + /* "src/pyscipopt/lp.pxi":384 + * nrows = self.nrows() + * cdef SCIP_Real* c_dualsol = malloc(nrows * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, c_dualsol, NULL, NULL)) # <<<<<<<<<<<<<< + * dualsol = [0.0] * nrows + * for i in range(nrows): + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetSol(__pyx_v_self->lpi, NULL, NULL, __pyx_v_c_dualsol, NULL, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":385 + * cdef SCIP_Real* c_dualsol = malloc(nrows * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, c_dualsol, NULL, NULL)) + * dualsol = [0.0] * nrows # <<<<<<<<<<<<<< + * for i in range(nrows): + * dualsol[i] = c_dualsol[i] + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_float_0_0); + __Pyx_GIVEREF(__pyx_float_0_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_float_0_0)) __PYX_ERR(2, 385, __pyx_L1_error); + { PyObject* __pyx_temp = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_nrows); if (unlikely(!__pyx_temp)) __PYX_ERR(2, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_temp); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_temp; + } + __pyx_v_dualsol = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":386 + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, c_dualsol, NULL, NULL)) + * dualsol = [0.0] * nrows + * for i in range(nrows): # <<<<<<<<<<<<<< + * dualsol[i] = c_dualsol[i] + * free(c_dualsol) + */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_v_nrows); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 386, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 386, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(2, 386, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 386, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(2, 386, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_8(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 386, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":387 + * dualsol = [0.0] * nrows + * for i in range(nrows): + * dualsol[i] = c_dualsol[i] # <<<<<<<<<<<<<< + * free(c_dualsol) + * + */ + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 387, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble((__pyx_v_c_dualsol[__pyx_t_9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely((PyObject_SetItem(__pyx_v_dualsol, __pyx_v_i, __pyx_t_2) < 0))) __PYX_ERR(2, 387, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":386 + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, c_dualsol, NULL, NULL)) + * dualsol = [0.0] * nrows + * for i in range(nrows): # <<<<<<<<<<<<<< + * dualsol[i] = c_dualsol[i] + * free(c_dualsol) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":388 + * for i in range(nrows): + * dualsol[i] = c_dualsol[i] + * free(c_dualsol) # <<<<<<<<<<<<<< + * + * return dualsol + */ + free(__pyx_v_c_dualsol); + + /* "src/pyscipopt/lp.pxi":390 + * free(c_dualsol) + * + * return dualsol # <<<<<<<<<<<<<< + * + * def isDualFeasible(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_dualsol); + __pyx_r = __pyx_v_dualsol; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":380 + * return SCIPlpiIsPrimalFeasible(self.lpi) + * + * def getDual(self): # <<<<<<<<<<<<<< + * """Returns the dual solution of the last LP solve.""" + * nrows = self.nrows() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.getDual", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nrows); + __Pyx_XDECREF(__pyx_v_dualsol); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":392 + * return dualsol + * + * def isDualFeasible(self): # <<<<<<<<<<<<<< + * """Returns True iff LP is proven to be dual feasible.""" + * return SCIPlpiIsDualFeasible(self.lpi) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_53isDualFeasible(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_52isDualFeasible, "LP.isDualFeasible(self)\nReturns True iff LP is proven to be dual feasible."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_53isDualFeasible = {"isDualFeasible", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_53isDualFeasible, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_52isDualFeasible}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_53isDualFeasible(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isDualFeasible (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isDualFeasible", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isDualFeasible", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_52isDualFeasible(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_52isDualFeasible(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isDualFeasible", 1); + + /* "src/pyscipopt/lp.pxi":394 + * def isDualFeasible(self): + * """Returns True iff LP is proven to be dual feasible.""" + * return SCIPlpiIsDualFeasible(self.lpi) # <<<<<<<<<<<<<< + * + * def getPrimalRay(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPlpiIsDualFeasible(__pyx_v_self->lpi)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":392 + * return dualsol + * + * def isDualFeasible(self): # <<<<<<<<<<<<<< + * """Returns True iff LP is proven to be dual feasible.""" + * return SCIPlpiIsDualFeasible(self.lpi) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.LP.isDualFeasible", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":396 + * return SCIPlpiIsDualFeasible(self.lpi) + * + * def getPrimalRay(self): # <<<<<<<<<<<<<< + * """Returns a primal ray if possible, None otherwise.""" + * if not SCIPlpiHasPrimalRay(self.lpi): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_55getPrimalRay(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_54getPrimalRay, "LP.getPrimalRay(self)\nReturns a primal ray if possible, None otherwise."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_55getPrimalRay = {"getPrimalRay", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_55getPrimalRay, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_54getPrimalRay}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_55getPrimalRay(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPrimalRay (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getPrimalRay", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPrimalRay", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_54getPrimalRay(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_54getPrimalRay(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_v_ncols = NULL; + SCIP_Real *__pyx_v_c_ray; + PyObject *__pyx_v_ray = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *(*__pyx_t_9)(PyObject *); + Py_ssize_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getPrimalRay", 1); + + /* "src/pyscipopt/lp.pxi":398 + * def getPrimalRay(self): + * """Returns a primal ray if possible, None otherwise.""" + * if not SCIPlpiHasPrimalRay(self.lpi): # <<<<<<<<<<<<<< + * return None + * ncols = self.ncols() + */ + __pyx_t_1 = (!(SCIPlpiHasPrimalRay(__pyx_v_self->lpi) != 0)); + if (__pyx_t_1) { + + /* "src/pyscipopt/lp.pxi":399 + * """Returns a primal ray if possible, None otherwise.""" + * if not SCIPlpiHasPrimalRay(self.lpi): + * return None # <<<<<<<<<<<<<< + * ncols = self.ncols() + * cdef SCIP_Real* c_ray = malloc(ncols * sizeof(SCIP_Real)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":398 + * def getPrimalRay(self): + * """Returns a primal ray if possible, None otherwise.""" + * if not SCIPlpiHasPrimalRay(self.lpi): # <<<<<<<<<<<<<< + * return None + * ncols = self.ncols() + */ + } + + /* "src/pyscipopt/lp.pxi":400 + * if not SCIPlpiHasPrimalRay(self.lpi): + * return None + * ncols = self.ncols() # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_ray = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetPrimalRay(self.lpi, c_ray)) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncols); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_ncols = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":401 + * return None + * ncols = self.ncols() + * cdef SCIP_Real* c_ray = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetPrimalRay(self.lpi, c_ray)) + * ray = [0.0] * ncols + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 401, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 401, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 401, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_ray = ((SCIP_Real *)malloc(__pyx_t_6)); + + /* "src/pyscipopt/lp.pxi":402 + * ncols = self.ncols() + * cdef SCIP_Real* c_ray = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetPrimalRay(self.lpi, c_ray)) # <<<<<<<<<<<<<< + * ray = [0.0] * ncols + * for i in range(ncols): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetPrimalRay(__pyx_v_self->lpi, __pyx_v_c_ray)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":403 + * cdef SCIP_Real* c_ray = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetPrimalRay(self.lpi, c_ray)) + * ray = [0.0] * ncols # <<<<<<<<<<<<<< + * for i in range(ncols): + * ray[i] = c_ray[i] + */ + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_float_0_0); + __Pyx_GIVEREF(__pyx_float_0_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_0)) __PYX_ERR(2, 403, __pyx_L1_error); + { PyObject* __pyx_temp = PyNumber_InPlaceMultiply(__pyx_t_3, __pyx_v_ncols); if (unlikely(!__pyx_temp)) __PYX_ERR(2, 403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_temp); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_temp; + } + __pyx_v_ray = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":404 + * PY_SCIP_CALL(SCIPlpiGetPrimalRay(self.lpi, c_ray)) + * ray = [0.0] * ncols + * for i in range(ncols): # <<<<<<<<<<<<<< + * ray[i] = c_ray[i] + * free(c_ray) + */ + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_v_ncols); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); + __pyx_t_8 = 0; + __pyx_t_9 = NULL; + } else { + __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 404, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_9)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 404, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(2, 404, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 404, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(2, 404, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_9(__pyx_t_2); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 404, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":405 + * ray = [0.0] * ncols + * for i in range(ncols): + * ray[i] = c_ray[i] # <<<<<<<<<<<<<< + * free(c_ray) + * + */ + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 405, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_c_ray[__pyx_t_10])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely((PyObject_SetItem(__pyx_v_ray, __pyx_v_i, __pyx_t_3) < 0))) __PYX_ERR(2, 405, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":404 + * PY_SCIP_CALL(SCIPlpiGetPrimalRay(self.lpi, c_ray)) + * ray = [0.0] * ncols + * for i in range(ncols): # <<<<<<<<<<<<<< + * ray[i] = c_ray[i] + * free(c_ray) + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":406 + * for i in range(ncols): + * ray[i] = c_ray[i] + * free(c_ray) # <<<<<<<<<<<<<< + * + * return ray + */ + free(__pyx_v_c_ray); + + /* "src/pyscipopt/lp.pxi":408 + * free(c_ray) + * + * return ray # <<<<<<<<<<<<<< + * + * def getDualRay(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_ray); + __pyx_r = __pyx_v_ray; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":396 + * return SCIPlpiIsDualFeasible(self.lpi) + * + * def getPrimalRay(self): # <<<<<<<<<<<<<< + * """Returns a primal ray if possible, None otherwise.""" + * if not SCIPlpiHasPrimalRay(self.lpi): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.LP.getPrimalRay", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ncols); + __Pyx_XDECREF(__pyx_v_ray); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":410 + * return ray + * + * def getDualRay(self): # <<<<<<<<<<<<<< + * """Returns a dual ray if possible, None otherwise.""" + * if not SCIPlpiHasDualRay(self.lpi): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_57getDualRay(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_56getDualRay, "LP.getDualRay(self)\nReturns a dual ray if possible, None otherwise."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_57getDualRay = {"getDualRay", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_57getDualRay, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_56getDualRay}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_57getDualRay(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDualRay (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getDualRay", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDualRay", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_56getDualRay(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_56getDualRay(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_v_nrows = NULL; + SCIP_Real *__pyx_v_c_ray; + PyObject *__pyx_v_ray = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *(*__pyx_t_9)(PyObject *); + Py_ssize_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDualRay", 1); + + /* "src/pyscipopt/lp.pxi":412 + * def getDualRay(self): + * """Returns a dual ray if possible, None otherwise.""" + * if not SCIPlpiHasDualRay(self.lpi): # <<<<<<<<<<<<<< + * return None + * nrows = self.nrows() + */ + __pyx_t_1 = (!(SCIPlpiHasDualRay(__pyx_v_self->lpi) != 0)); + if (__pyx_t_1) { + + /* "src/pyscipopt/lp.pxi":413 + * """Returns a dual ray if possible, None otherwise.""" + * if not SCIPlpiHasDualRay(self.lpi): + * return None # <<<<<<<<<<<<<< + * nrows = self.nrows() + * cdef SCIP_Real* c_ray = malloc(nrows * sizeof(SCIP_Real)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":412 + * def getDualRay(self): + * """Returns a dual ray if possible, None otherwise.""" + * if not SCIPlpiHasDualRay(self.lpi): # <<<<<<<<<<<<<< + * return None + * nrows = self.nrows() + */ + } + + /* "src/pyscipopt/lp.pxi":414 + * if not SCIPlpiHasDualRay(self.lpi): + * return None + * nrows = self.nrows() # <<<<<<<<<<<<<< + * cdef SCIP_Real* c_ray = malloc(nrows * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetDualfarkas(self.lpi, c_ray)) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_nrows); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 414, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_nrows = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":415 + * return None + * nrows = self.nrows() + * cdef SCIP_Real* c_ray = malloc(nrows * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetDualfarkas(self.lpi, c_ray)) + * ray = [0.0] * nrows + */ + __pyx_t_2 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_nrows, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 415, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_c_ray = ((SCIP_Real *)malloc(__pyx_t_6)); + + /* "src/pyscipopt/lp.pxi":416 + * nrows = self.nrows() + * cdef SCIP_Real* c_ray = malloc(nrows * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetDualfarkas(self.lpi, c_ray)) # <<<<<<<<<<<<<< + * ray = [0.0] * nrows + * for i in range(nrows): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetDualfarkas(__pyx_v_self->lpi, __pyx_v_c_ray)); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":417 + * cdef SCIP_Real* c_ray = malloc(nrows * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetDualfarkas(self.lpi, c_ray)) + * ray = [0.0] * nrows # <<<<<<<<<<<<<< + * for i in range(nrows): + * ray[i] = c_ray[i] + */ + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_float_0_0); + __Pyx_GIVEREF(__pyx_float_0_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_float_0_0)) __PYX_ERR(2, 417, __pyx_L1_error); + { PyObject* __pyx_temp = PyNumber_InPlaceMultiply(__pyx_t_3, __pyx_v_nrows); if (unlikely(!__pyx_temp)) __PYX_ERR(2, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_temp); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_temp; + } + __pyx_v_ray = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":418 + * PY_SCIP_CALL(SCIPlpiGetDualfarkas(self.lpi, c_ray)) + * ray = [0.0] * nrows + * for i in range(nrows): # <<<<<<<<<<<<<< + * ray[i] = c_ray[i] + * free(c_ray) + */ + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_v_nrows); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); + __pyx_t_8 = 0; + __pyx_t_9 = NULL; + } else { + __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 418, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_9)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 418, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(2, 418, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 418, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_3); __pyx_t_8++; if (unlikely((0 < 0))) __PYX_ERR(2, 418, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_9(__pyx_t_2); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 418, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":419 + * ray = [0.0] * nrows + * for i in range(nrows): + * ray[i] = c_ray[i] # <<<<<<<<<<<<<< + * free(c_ray) + * + */ + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 419, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_c_ray[__pyx_t_10])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely((PyObject_SetItem(__pyx_v_ray, __pyx_v_i, __pyx_t_3) < 0))) __PYX_ERR(2, 419, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":418 + * PY_SCIP_CALL(SCIPlpiGetDualfarkas(self.lpi, c_ray)) + * ray = [0.0] * nrows + * for i in range(nrows): # <<<<<<<<<<<<<< + * ray[i] = c_ray[i] + * free(c_ray) + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":420 + * for i in range(nrows): + * ray[i] = c_ray[i] + * free(c_ray) # <<<<<<<<<<<<<< + * + * return ray + */ + free(__pyx_v_c_ray); + + /* "src/pyscipopt/lp.pxi":422 + * free(c_ray) + * + * return ray # <<<<<<<<<<<<<< + * + * def getNIterations(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_ray); + __pyx_r = __pyx_v_ray; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":410 + * return ray + * + * def getDualRay(self): # <<<<<<<<<<<<<< + * """Returns a dual ray if possible, None otherwise.""" + * if not SCIPlpiHasDualRay(self.lpi): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.LP.getDualRay", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nrows); + __Pyx_XDECREF(__pyx_v_ray); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":424 + * return ray + * + * def getNIterations(self): # <<<<<<<<<<<<<< + * """Returns the number of LP iterations of the last LP solve.""" + * cdef int niters + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_59getNIterations(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_58getNIterations, "LP.getNIterations(self)\nReturns the number of LP iterations of the last LP solve."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_59getNIterations = {"getNIterations", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_59getNIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_58getNIterations}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_59getNIterations(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNIterations (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNIterations", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNIterations", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_58getNIterations(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_58getNIterations(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + int __pyx_v_niters; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNIterations", 1); + + /* "src/pyscipopt/lp.pxi":427 + * """Returns the number of LP iterations of the last LP solve.""" + * cdef int niters + * PY_SCIP_CALL(SCIPlpiGetIterations(self.lpi, &niters)) # <<<<<<<<<<<<<< + * return niters + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetIterations(__pyx_v_self->lpi, (&__pyx_v_niters))); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":428 + * cdef int niters + * PY_SCIP_CALL(SCIPlpiGetIterations(self.lpi, &niters)) + * return niters # <<<<<<<<<<<<<< + * + * def getRedcost(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_niters); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":424 + * return ray + * + * def getNIterations(self): # <<<<<<<<<<<<<< + * """Returns the number of LP iterations of the last LP solve.""" + * cdef int niters + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.LP.getNIterations", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":430 + * return niters + * + * def getRedcost(self): # <<<<<<<<<<<<<< + * """Returns the reduced cost vector of the last LP solve.""" + * ncols = self.ncols() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_61getRedcost(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_60getRedcost, "LP.getRedcost(self)\nReturns the reduced cost vector of the last LP solve."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_61getRedcost = {"getRedcost", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_61getRedcost, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_60getRedcost}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_61getRedcost(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRedcost (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getRedcost", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRedcost", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_60getRedcost(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_60getRedcost(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_v_ncols = NULL; + SCIP_Real *__pyx_v_c_redcost; + PyObject *__pyx_v_redcost = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRedcost", 1); + + /* "src/pyscipopt/lp.pxi":432 + * def getRedcost(self): + * """Returns the reduced cost vector of the last LP solve.""" + * ncols = self.ncols() # <<<<<<<<<<<<<< + * + * cdef SCIP_Real* c_redcost = malloc(ncols * sizeof(SCIP_Real)) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncols); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_ncols = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":434 + * ncols = self.ncols() + * + * cdef SCIP_Real* c_redcost = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, NULL, NULL, c_redcost)) + * + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_Real))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_ncols, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 434, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_redcost = ((SCIP_Real *)malloc(__pyx_t_5)); + + /* "src/pyscipopt/lp.pxi":435 + * + * cdef SCIP_Real* c_redcost = malloc(ncols * sizeof(SCIP_Real)) + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, NULL, NULL, c_redcost)) # <<<<<<<<<<<<<< + * + * redcost = [] + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetSol(__pyx_v_self->lpi, NULL, NULL, NULL, NULL, __pyx_v_c_redcost)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":437 + * PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, NULL, NULL, c_redcost)) + * + * redcost = [] # <<<<<<<<<<<<<< + * for i in range(ncols): + * redcost[i].append(c_redcost[i]) + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_redcost = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":438 + * + * redcost = [] + * for i in range(ncols): # <<<<<<<<<<<<<< + * redcost[i].append(c_redcost[i]) + * + */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_v_ncols); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 438, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 438, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(2, 438, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 438, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(2, 438, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_8(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 438, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":439 + * redcost = [] + * for i in range(ncols): + * redcost[i].append(c_redcost[i]) # <<<<<<<<<<<<<< + * + * free(c_redcost) + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_v_redcost, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 439, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_c_redcost[__pyx_t_9])); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_Append(__pyx_t_2, __pyx_t_3); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(2, 439, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/lp.pxi":438 + * + * redcost = [] + * for i in range(ncols): # <<<<<<<<<<<<<< + * redcost[i].append(c_redcost[i]) + * + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":441 + * redcost[i].append(c_redcost[i]) + * + * free(c_redcost) # <<<<<<<<<<<<<< + * return redcost + * + */ + free(__pyx_v_c_redcost); + + /* "src/pyscipopt/lp.pxi":442 + * + * free(c_redcost) + * return redcost # <<<<<<<<<<<<<< + * + * def getBasisInds(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_redcost); + __pyx_r = __pyx_v_redcost; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":430 + * return niters + * + * def getRedcost(self): # <<<<<<<<<<<<<< + * """Returns the reduced cost vector of the last LP solve.""" + * ncols = self.ncols() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.getRedcost", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ncols); + __Pyx_XDECREF(__pyx_v_redcost); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":444 + * return redcost + * + * def getBasisInds(self): # <<<<<<<<<<<<<< + * """Returns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * nrows = self.nrows() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_63getBasisInds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_62getBasisInds, "LP.getBasisInds(self)\nReturns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_63getBasisInds = {"getBasisInds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_63getBasisInds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_62getBasisInds}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_63getBasisInds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBasisInds (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBasisInds", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBasisInds", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_62getBasisInds(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_62getBasisInds(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_v_nrows = NULL; + int *__pyx_v_c_binds; + PyObject *__pyx_v_binds = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBasisInds", 1); + + /* "src/pyscipopt/lp.pxi":446 + * def getBasisInds(self): + * """Returns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * nrows = self.nrows() # <<<<<<<<<<<<<< + * cdef int* c_binds = malloc(nrows * sizeof(int)) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_nrows); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_nrows = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":447 + * """Returns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * nrows = self.nrows() + * cdef int* c_binds = malloc(nrows * sizeof(int)) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPlpiGetBasisInd(self.lpi, c_binds)) + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(int))); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Multiply(__pyx_v_nrows, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_2); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 447, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_c_binds = ((int *)malloc(__pyx_t_5)); + + /* "src/pyscipopt/lp.pxi":449 + * cdef int* c_binds = malloc(nrows * sizeof(int)) + * + * PY_SCIP_CALL(SCIPlpiGetBasisInd(self.lpi, c_binds)) # <<<<<<<<<<<<<< + * + * binds = [] + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetBasisInd(__pyx_v_self->lpi, __pyx_v_c_binds)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":451 + * PY_SCIP_CALL(SCIPlpiGetBasisInd(self.lpi, c_binds)) + * + * binds = [] # <<<<<<<<<<<<<< + * for i in range(nrows): + * binds.append(c_binds[i]) + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_binds = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":452 + * + * binds = [] + * for i in range(nrows): # <<<<<<<<<<<<<< + * binds.append(c_binds[i]) + * + */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_v_nrows); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); + __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 452, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 452, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(2, 452, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(2, 452, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_7); __Pyx_INCREF(__pyx_t_2); __pyx_t_7++; if (unlikely((0 < 0))) __PYX_ERR(2, 452, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_8(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(2, 452, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":453 + * binds = [] + * for i in range(nrows): + * binds.append(c_binds[i]) # <<<<<<<<<<<<<< + * + * free(c_binds) + */ + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(2, 453, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_v_c_binds[__pyx_t_9])); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 453, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_binds, __pyx_t_2); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(2, 453, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/lp.pxi":452 + * + * binds = [] + * for i in range(nrows): # <<<<<<<<<<<<<< + * binds.append(c_binds[i]) + * + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/lp.pxi":455 + * binds.append(c_binds[i]) + * + * free(c_binds) # <<<<<<<<<<<<<< + * return binds + */ + free(__pyx_v_c_binds); + + /* "src/pyscipopt/lp.pxi":456 + * + * free(c_binds) + * return binds # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_binds); + __pyx_r = __pyx_v_binds; + goto __pyx_L0; + + /* "src/pyscipopt/lp.pxi":444 + * return redcost + * + * def getBasisInds(self): # <<<<<<<<<<<<<< + * """Returns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * nrows = self.nrows() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.LP.getBasisInds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nrows); + __Pyx_XDECREF(__pyx_v_binds); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/lp.pxi":5 + * cdef class LP: + * cdef SCIP_LPI* lpi + * cdef readonly str name # <<<<<<<<<<<<<< + * + * def __init__(self, name="LP", sense="minimize"): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_4name___get__(struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_65__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_64__reduce_cython__, "LP.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_65__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_65__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_64__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_65__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_64__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_64__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_lpi_cannot_be_converted_to, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.LP.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_67__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_2LP_66__setstate_cython__, "LP.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_2LP_67__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_67__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_66__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_2LP_67__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.LP.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_2LP_66__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_LP *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_2LP_66__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_LP *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_lpi_cannot_be_converted_to, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.LP.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":8 + * cdef SCIP_BENDERS* _benders + * + * def bendersfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of Benders decomposition ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_1bendersfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_bendersfree, "Benders.bendersfree(self)\ncalls destructor and frees memory of Benders decomposition "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_1bendersfree = {"bendersfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_1bendersfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_bendersfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_1bendersfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("bendersfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bendersfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_bendersfree(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_bendersfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":12 + * pass + * + * def bendersinit(self): # <<<<<<<<<<<<<< + * '''initializes Benders deconposition''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_3bendersinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_2bendersinit, "Benders.bendersinit(self)\ninitializes Benders deconposition"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_3bendersinit = {"bendersinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_3bendersinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_2bendersinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_3bendersinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("bendersinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bendersinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_2bendersinit(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_2bendersinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":16 + * pass + * + * def bendersexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of Benders decomposition''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_5bendersexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_4bendersexit, "Benders.bendersexit(self)\ncalls exit method of Benders decomposition"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_5bendersexit = {"bendersexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_5bendersexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_4bendersexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_5bendersexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("bendersexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bendersexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_4bendersexit(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_4bendersexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":20 + * pass + * + * def bendersinitpre(self): # <<<<<<<<<<<<<< + * '''informs the Benders decomposition that the presolving process is being started ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_7bendersinitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_6bendersinitpre, "Benders.bendersinitpre(self)\ninforms the Benders decomposition that the presolving process is being started "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_7bendersinitpre = {"bendersinitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_7bendersinitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_6bendersinitpre}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_7bendersinitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersinitpre (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("bendersinitpre", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bendersinitpre", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_6bendersinitpre(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_6bendersinitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersinitpre", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":24 + * pass + * + * def bendersexitpre(self): # <<<<<<<<<<<<<< + * '''informs the Benders decomposition that the presolving process has been completed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_9bendersexitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_8bendersexitpre, "Benders.bendersexitpre(self)\ninforms the Benders decomposition that the presolving process has been completed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_9bendersexitpre = {"bendersexitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_9bendersexitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_8bendersexitpre}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_9bendersexitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersexitpre (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("bendersexitpre", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bendersexitpre", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_8bendersexitpre(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_8bendersexitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersexitpre", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":28 + * pass + * + * def bendersinitsol(self): # <<<<<<<<<<<<<< + * '''informs Benders decomposition that the branch and bound process is being started ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_11bendersinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_10bendersinitsol, "Benders.bendersinitsol(self)\ninforms Benders decomposition that the branch and bound process is being started "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_11bendersinitsol = {"bendersinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_11bendersinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_10bendersinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_11bendersinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("bendersinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bendersinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_10bendersinitsol(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_10bendersinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":32 + * pass + * + * def bendersexitsol(self): # <<<<<<<<<<<<<< + * '''informs Benders decomposition that the branch and bound process data is being freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_13bendersexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_12bendersexitsol, "Benders.bendersexitsol(self)\ninforms Benders decomposition that the branch and bound process data is being freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_13bendersexitsol = {"bendersexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_13bendersexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_12bendersexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_13bendersexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("bendersexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bendersexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_12bendersexitsol(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_12bendersexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":36 + * pass + * + * def benderscreatesub(self, probnumber): # <<<<<<<<<<<<<< + * '''creates the subproblems and registers it with the Benders decomposition struct ''' + * print("python error in benderscreatesub: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_15benderscreatesub(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_14benderscreatesub, "Benders.benderscreatesub(self, probnumber)\ncreates the subproblems and registers it with the Benders decomposition struct "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_15benderscreatesub = {"benderscreatesub", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_15benderscreatesub, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_14benderscreatesub}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_15benderscreatesub(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_probnumber = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscreatesub (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_probnumber,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 36, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "benderscreatesub") < 0)) __PYX_ERR(3, 36, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_probnumber = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("benderscreatesub", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 36, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderscreatesub", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_14benderscreatesub(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), __pyx_v_probnumber); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_14benderscreatesub(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_probnumber) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("benderscreatesub", 1); + + /* "src/pyscipopt/benders.pxi":38 + * def benderscreatesub(self, probnumber): + * '''creates the subproblems and registers it with the Benders decomposition struct ''' + * print("python error in benderscreatesub: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":39 + * '''creates the subproblems and registers it with the Benders decomposition struct ''' + * print("python error in benderscreatesub: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * def benderspresubsolve(self, solution, enfotype, checkint): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":36 + * pass + * + * def benderscreatesub(self, probnumber): # <<<<<<<<<<<<<< + * '''creates the subproblems and registers it with the Benders decomposition struct ''' + * print("python error in benderscreatesub: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderscreatesub", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":41 + * return {} + * + * def benderspresubsolve(self, solution, enfotype, checkint): # <<<<<<<<<<<<<< + * '''sets the pre subproblem solve callback of Benders decomposition ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_17benderspresubsolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_16benderspresubsolve, "Benders.benderspresubsolve(self, solution, enfotype, checkint)\nsets the pre subproblem solve callback of Benders decomposition "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_17benderspresubsolve = {"benderspresubsolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_17benderspresubsolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_16benderspresubsolve}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_17benderspresubsolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + CYTHON_UNUSED PyObject *__pyx_v_enfotype = 0; + CYTHON_UNUSED PyObject *__pyx_v_checkint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderspresubsolve (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_enfotype,&__pyx_n_s_checkint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 41, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enfotype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 41, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderspresubsolve", 1, 3, 3, 1); __PYX_ERR(3, 41, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checkint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 41, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderspresubsolve", 1, 3, 3, 2); __PYX_ERR(3, 41, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "benderspresubsolve") < 0)) __PYX_ERR(3, 41, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_solution = values[0]; + __pyx_v_enfotype = values[1]; + __pyx_v_checkint = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("benderspresubsolve", 1, 3, 3, __pyx_nargs); __PYX_ERR(3, 41, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderspresubsolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_16benderspresubsolve(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), __pyx_v_solution, __pyx_v_enfotype, __pyx_v_checkint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_16benderspresubsolve(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_enfotype, CYTHON_UNUSED PyObject *__pyx_v_checkint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("benderspresubsolve", 1); + + /* "src/pyscipopt/benders.pxi":43 + * def benderspresubsolve(self, solution, enfotype, checkint): + * '''sets the pre subproblem solve callback of Benders decomposition ''' + * return {} # <<<<<<<<<<<<<< + * + * def benderssolvesubconvex(self, solution, probnumber, onlyconvex): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":41 + * return {} + * + * def benderspresubsolve(self, solution, enfotype, checkint): # <<<<<<<<<<<<<< + * '''sets the pre subproblem solve callback of Benders decomposition ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderspresubsolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":45 + * return {} + * + * def benderssolvesubconvex(self, solution, probnumber, onlyconvex): # <<<<<<<<<<<<<< + * '''sets convex solve callback of Benders decomposition''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_19benderssolvesubconvex(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_18benderssolvesubconvex, "Benders.benderssolvesubconvex(self, solution, probnumber, onlyconvex)\nsets convex solve callback of Benders decomposition"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_19benderssolvesubconvex = {"benderssolvesubconvex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_19benderssolvesubconvex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_18benderssolvesubconvex}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_19benderssolvesubconvex(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + CYTHON_UNUSED PyObject *__pyx_v_probnumber = 0; + CYTHON_UNUSED PyObject *__pyx_v_onlyconvex = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderssolvesubconvex (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_probnumber,&__pyx_n_s_onlyconvex,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 45, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 45, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderssolvesubconvex", 1, 3, 3, 1); __PYX_ERR(3, 45, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_onlyconvex)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 45, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderssolvesubconvex", 1, 3, 3, 2); __PYX_ERR(3, 45, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "benderssolvesubconvex") < 0)) __PYX_ERR(3, 45, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_solution = values[0]; + __pyx_v_probnumber = values[1]; + __pyx_v_onlyconvex = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("benderssolvesubconvex", 1, 3, 3, __pyx_nargs); __PYX_ERR(3, 45, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderssolvesubconvex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_18benderssolvesubconvex(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), __pyx_v_solution, __pyx_v_probnumber, __pyx_v_onlyconvex); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_18benderssolvesubconvex(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_probnumber, CYTHON_UNUSED PyObject *__pyx_v_onlyconvex) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("benderssolvesubconvex", 1); + + /* "src/pyscipopt/benders.pxi":47 + * def benderssolvesubconvex(self, solution, probnumber, onlyconvex): + * '''sets convex solve callback of Benders decomposition''' + * return {} # <<<<<<<<<<<<<< + * + * def benderssolvesub(self, solution, probnumber): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":45 + * return {} + * + * def benderssolvesubconvex(self, solution, probnumber, onlyconvex): # <<<<<<<<<<<<<< + * '''sets convex solve callback of Benders decomposition''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderssolvesubconvex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":49 + * return {} + * + * def benderssolvesub(self, solution, probnumber): # <<<<<<<<<<<<<< + * '''sets solve callback of Benders decomposition ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_21benderssolvesub(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_20benderssolvesub, "Benders.benderssolvesub(self, solution, probnumber)\nsets solve callback of Benders decomposition "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_21benderssolvesub = {"benderssolvesub", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_21benderssolvesub, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_20benderssolvesub}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_21benderssolvesub(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + CYTHON_UNUSED PyObject *__pyx_v_probnumber = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderssolvesub (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_probnumber,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 49, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 49, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderssolvesub", 1, 2, 2, 1); __PYX_ERR(3, 49, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "benderssolvesub") < 0)) __PYX_ERR(3, 49, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_solution = values[0]; + __pyx_v_probnumber = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("benderssolvesub", 1, 2, 2, __pyx_nargs); __PYX_ERR(3, 49, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderssolvesub", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_20benderssolvesub(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), __pyx_v_solution, __pyx_v_probnumber); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_20benderssolvesub(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_probnumber) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("benderssolvesub", 1); + + /* "src/pyscipopt/benders.pxi":51 + * def benderssolvesub(self, solution, probnumber): + * '''sets solve callback of Benders decomposition ''' + * return {} # <<<<<<<<<<<<<< + * + * def benderspostsolve(self, solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":49 + * return {} + * + * def benderssolvesub(self, solution, probnumber): # <<<<<<<<<<<<<< + * '''sets solve callback of Benders decomposition ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderssolvesub", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":53 + * return {} + * + * def benderspostsolve(self, solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible): # <<<<<<<<<<<<<< + * '''sets post-solve callback of Benders decomposition ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_23benderspostsolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_22benderspostsolve, "Benders.benderspostsolve(self, solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible)\nsets post-solve callback of Benders decomposition "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_23benderspostsolve = {"benderspostsolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_23benderspostsolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_22benderspostsolve}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_23benderspostsolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + CYTHON_UNUSED PyObject *__pyx_v_enfotype = 0; + CYTHON_UNUSED PyObject *__pyx_v_mergecandidates = 0; + CYTHON_UNUSED PyObject *__pyx_v_npriomergecands = 0; + CYTHON_UNUSED PyObject *__pyx_v_checkint = 0; + CYTHON_UNUSED PyObject *__pyx_v_infeasible = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[6] = {0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderspostsolve (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_enfotype,&__pyx_n_s_mergecandidates,&__pyx_n_s_npriomergecands,&__pyx_n_s_checkint,&__pyx_n_s_infeasible,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 53, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enfotype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 53, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderspostsolve", 1, 6, 6, 1); __PYX_ERR(3, 53, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mergecandidates)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 53, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderspostsolve", 1, 6, 6, 2); __PYX_ERR(3, 53, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_npriomergecands)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 53, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderspostsolve", 1, 6, 6, 3); __PYX_ERR(3, 53, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checkint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 53, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderspostsolve", 1, 6, 6, 4); __PYX_ERR(3, 53, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_infeasible)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[5]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 53, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderspostsolve", 1, 6, 6, 5); __PYX_ERR(3, 53, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "benderspostsolve") < 0)) __PYX_ERR(3, 53, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 6)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + } + __pyx_v_solution = values[0]; + __pyx_v_enfotype = values[1]; + __pyx_v_mergecandidates = values[2]; + __pyx_v_npriomergecands = values[3]; + __pyx_v_checkint = values[4]; + __pyx_v_infeasible = values[5]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("benderspostsolve", 1, 6, 6, __pyx_nargs); __PYX_ERR(3, 53, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderspostsolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_22benderspostsolve(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), __pyx_v_solution, __pyx_v_enfotype, __pyx_v_mergecandidates, __pyx_v_npriomergecands, __pyx_v_checkint, __pyx_v_infeasible); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_22benderspostsolve(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_enfotype, CYTHON_UNUSED PyObject *__pyx_v_mergecandidates, CYTHON_UNUSED PyObject *__pyx_v_npriomergecands, CYTHON_UNUSED PyObject *__pyx_v_checkint, CYTHON_UNUSED PyObject *__pyx_v_infeasible) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("benderspostsolve", 1); + + /* "src/pyscipopt/benders.pxi":55 + * def benderspostsolve(self, solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible): + * '''sets post-solve callback of Benders decomposition ''' + * return {} # <<<<<<<<<<<<<< + * + * def bendersfreesub(self, probnumber): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":53 + * return {} + * + * def benderspostsolve(self, solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible): # <<<<<<<<<<<<<< + * '''sets post-solve callback of Benders decomposition ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benders.benderspostsolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":57 + * return {} + * + * def bendersfreesub(self, probnumber): # <<<<<<<<<<<<<< + * '''frees the subproblems''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_25bendersfreesub(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_24bendersfreesub, "Benders.bendersfreesub(self, probnumber)\nfrees the subproblems"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_25bendersfreesub = {"bendersfreesub", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_25bendersfreesub, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_24bendersfreesub}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_25bendersfreesub(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_probnumber = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersfreesub (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_probnumber,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 57, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "bendersfreesub") < 0)) __PYX_ERR(3, 57, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_probnumber = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("bendersfreesub", 1, 1, 1, __pyx_nargs); __PYX_ERR(3, 57, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benders.bendersfreesub", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_24bendersfreesub(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), __pyx_v_probnumber); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_24bendersfreesub(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_probnumber) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersfreesub", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":61 + * pass + * + * def bendersgetvar(self, variable, probnumber): # <<<<<<<<<<<<<< + * '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. ''' + * print("python error in bendersgetvar: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_27bendersgetvar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_26bendersgetvar, "Benders.bendersgetvar(self, variable, probnumber)\nReturns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_27bendersgetvar = {"bendersgetvar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_27bendersgetvar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_26bendersgetvar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_27bendersgetvar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_variable = 0; + CYTHON_UNUSED PyObject *__pyx_v_probnumber = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bendersgetvar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_variable,&__pyx_n_s_probnumber,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_variable)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 61, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(3, 61, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("bendersgetvar", 1, 2, 2, 1); __PYX_ERR(3, 61, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "bendersgetvar") < 0)) __PYX_ERR(3, 61, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_variable = values[0]; + __pyx_v_probnumber = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("bendersgetvar", 1, 2, 2, __pyx_nargs); __PYX_ERR(3, 61, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benders.bendersgetvar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_26bendersgetvar(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), __pyx_v_variable, __pyx_v_probnumber); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_26bendersgetvar(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_variable, CYTHON_UNUSED PyObject *__pyx_v_probnumber) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("bendersgetvar", 1); + + /* "src/pyscipopt/benders.pxi":63 + * def bendersgetvar(self, variable, probnumber): + * '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. ''' + * print("python error in bendersgetvar: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":64 + * '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. ''' + * print("python error in bendersgetvar: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * # local helper functions for the interface + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":61 + * pass + * + * def bendersgetvar(self, variable, probnumber): # <<<<<<<<<<<<<< + * '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. ''' + * print("python error in bendersgetvar: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benders.bendersgetvar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":4 + * #@brief Base class of the Benders decomposition Plugin + * cdef class Benders: + * cdef public Model model # <<<<<<<<<<<<<< + * cdef public str name + * cdef SCIP_BENDERS* _benders + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7Benders_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7Benders_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7Benders_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(3, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benders.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7Benders_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7Benders_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7Benders_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":5 + * cdef class Benders: + * cdef public Model model + * cdef public str name # <<<<<<<<<<<<<< + * cdef SCIP_BENDERS* _benders + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7Benders_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7Benders_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_4name_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7Benders_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(PyUnicode_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_value))) __PYX_ERR(3, 5, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benders.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7Benders_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7Benders_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_4name_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7Benders_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_29__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_28__reduce_cython__, "Benders.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_29__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_29__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_28__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_29__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_28__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_28__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__benders_cannot_be_converte, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Benders.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_31__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Benders_30__setstate_cython__, "Benders.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Benders_31__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_31__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_30__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Benders_31__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benders.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Benders_30__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Benders_30__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__benders_cannot_be_converte, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Benders.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":67 + * + * # local helper functions for the interface + * cdef Variable getPyVar(SCIP_VAR* var): # <<<<<<<<<<<<<< + * cdef SCIP_VARDATA* vardata + * vardata = SCIPvarGetData(var) + */ + +static struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_f_9pyscipopt_4scip_getPyVar(SCIP_VAR *__pyx_v_var) { + SCIP_VARDATA *__pyx_v_vardata; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPyVar", 1); + + /* "src/pyscipopt/benders.pxi":69 + * cdef Variable getPyVar(SCIP_VAR* var): + * cdef SCIP_VARDATA* vardata + * vardata = SCIPvarGetData(var) # <<<<<<<<<<<<<< + * return vardata + * + */ + __pyx_v_vardata = SCIPvarGetData(__pyx_v_var); + + /* "src/pyscipopt/benders.pxi":70 + * cdef SCIP_VARDATA* vardata + * vardata = SCIPvarGetData(var) + * return vardata # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_vardata)); + __pyx_r = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_vardata); + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":67 + * + * # local helper functions for the interface + * cdef Variable getPyVar(SCIP_VAR* var): # <<<<<<<<<<<<<< + * cdef SCIP_VARDATA* vardata + * vardata = SCIPvarGetData(var) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":73 + * + * + * cdef SCIP_RETCODE PyBendersCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_Bool threadsafe) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_BENDERS *__pyx_v_benders, CYTHON_UNUSED SCIP_Bool __pyx_v_threadsafe) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/benders.pxi":74 + * + * cdef SCIP_RETCODE PyBendersCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_Bool threadsafe) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersFree (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":73 + * + * + * cdef SCIP_RETCODE PyBendersCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_Bool threadsafe) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":76 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersFree (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersFree", 0); + + /* "src/pyscipopt/benders.pxi":78 + * cdef SCIP_RETCODE PyBendersFree (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.bendersfree() + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":79 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.bendersfree() + * Py_DECREF(PyBenders) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":80 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.bendersfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyBenders) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":81 + * PyBenders = bendersdata + * PyBenders.bendersfree() + * Py_DECREF(PyBenders) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyBenders)); + + /* "src/pyscipopt/benders.pxi":82 + * PyBenders.bendersfree() + * Py_DECREF(PyBenders) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersInit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":76 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersFree (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":84 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersInit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersInit", 0); + + /* "src/pyscipopt/benders.pxi":86 + * cdef SCIP_RETCODE PyBendersInit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.bendersinit() + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":87 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.bendersinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":88 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.bendersinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":89 + * PyBenders = bendersdata + * PyBenders.bendersinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersExit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":84 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersInit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":91 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersExit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersExit", 0); + + /* "src/pyscipopt/benders.pxi":93 + * cdef SCIP_RETCODE PyBendersExit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.bendersexit() + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":94 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.bendersexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":95 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.bendersexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 95, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":96 + * PyBenders = bendersdata + * PyBenders.bendersexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersInitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":91 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersExit (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":98 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersInitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersInitpre(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersInitpre", 0); + + /* "src/pyscipopt/benders.pxi":100 + * cdef SCIP_RETCODE PyBendersInitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.bendersinitpre() + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":101 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.bendersinitpre() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":102 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.bendersinitpre() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersinitpre); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":103 + * PyBenders = bendersdata + * PyBenders.bendersinitpre() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersExitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":98 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersInitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersInitpre", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":105 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersExitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersExitpre(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersExitpre", 0); + + /* "src/pyscipopt/benders.pxi":107 + * cdef SCIP_RETCODE PyBendersExitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.bendersexitpre() + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":108 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.bendersexitpre() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":109 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.bendersexitpre() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersexitpre); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":110 + * PyBenders = bendersdata + * PyBenders.bendersexitpre() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersInitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":105 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersExitpre (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersExitpre", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":112 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersInitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersInitsol", 0); + + /* "src/pyscipopt/benders.pxi":114 + * cdef SCIP_RETCODE PyBendersInitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.bendersinitsol() + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":115 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.bendersinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":116 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.bendersinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":117 + * PyBenders = bendersdata + * PyBenders.bendersinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersExitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":112 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersInitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":119 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersExitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersExitsol", 0); + + /* "src/pyscipopt/benders.pxi":121 + * cdef SCIP_RETCODE PyBendersExitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.bendersexitsol() + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":122 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.bendersexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":123 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.bendersexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":124 + * PyBenders = bendersdata + * PyBenders.bendersexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersCreatesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":119 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersExitsol (SCIP* scip, SCIP_BENDERS* benders) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":126 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersCreatesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersCreatesub(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders, int __pyx_v_probnumber) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersCreatesub", 0); + + /* "src/pyscipopt/benders.pxi":128 + * cdef SCIP_RETCODE PyBendersCreatesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.benderscreatesub(probnumber) + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":129 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.benderscreatesub(probnumber) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":130 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.benderscreatesub(probnumber) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_benderscreatesub); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_probnumber); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":131 + * PyBenders = bendersdata + * PyBenders.benderscreatesub(probnumber) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersPresubsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint, SCIP_Bool* infeasible, SCIP_Bool* auxviol, SCIP_Bool* skipsolve, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":126 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersCreatesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersCreatesub", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":133 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersPresubsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint, SCIP_Bool* infeasible, SCIP_Bool* auxviol, SCIP_Bool* skipsolve, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersPresubsolve(SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders, SCIP_SOL *__pyx_v_sol, SCIP_BENDERSENFOTYPE __pyx_v_type, SCIP_Bool __pyx_v_checkint, SCIP_Bool *__pyx_v_infeasible, SCIP_Bool *__pyx_v_auxviol, SCIP_Bool *__pyx_v_skipsolve, SCIP_RESULT *__pyx_v_result) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + PyObject *__pyx_v_solution = NULL; + SCIP_BENDERSENFOTYPE __pyx_v_enfotype; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + SCIP_Bool __pyx_t_8; + SCIP_RESULT __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersPresubsolve", 0); + + /* "src/pyscipopt/benders.pxi":135 + * cdef SCIP_RETCODE PyBendersPresubsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint, SCIP_Bool* infeasible, SCIP_Bool* auxviol, SCIP_Bool* skipsolve, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * if sol == NULL: + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":136 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * if sol == NULL: + * solution = None + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":137 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + __pyx_t_2 = (__pyx_v_sol == NULL); + if (__pyx_t_2) { + + /* "src/pyscipopt/benders.pxi":138 + * PyBenders = bendersdata + * if sol == NULL: + * solution = None # <<<<<<<<<<<<<< + * else: + * solution = Solution.create(scip, sol) + */ + __Pyx_INCREF(Py_None); + __pyx_v_solution = Py_None; + + /* "src/pyscipopt/benders.pxi":137 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/benders.pxi":140 + * solution = None + * else: + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * enfotype = type + * result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) + */ + /*else*/ { + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/benders.pxi":141 + * else: + * solution = Solution.create(scip, sol) + * enfotype = type # <<<<<<<<<<<<<< + * result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) + * infeasible[0] = result_dict.get("infeasible", False) + */ + __pyx_v_enfotype = __pyx_v_type; + + /* "src/pyscipopt/benders.pxi":142 + * solution = Solution.create(scip, sol) + * enfotype = type + * result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) # <<<<<<<<<<<<<< + * infeasible[0] = result_dict.get("infeasible", False) + * auxviol[0] = result_dict.get("auxviol", False) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_benderspresubsolve); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(__pyx_v_enfotype); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_checkint); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_v_solution, __pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 3+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":143 + * enfotype = type + * result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) + * infeasible[0] = result_dict.get("infeasible", False) # <<<<<<<<<<<<<< + * auxviol[0] = result_dict.get("auxviol", False) + * skipsolve[0] = result_dict.get("skipsolve", False) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(3, 143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + (__pyx_v_infeasible[0]) = __pyx_t_8; + + /* "src/pyscipopt/benders.pxi":144 + * result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) + * infeasible[0] = result_dict.get("infeasible", False) + * auxviol[0] = result_dict.get("auxviol", False) # <<<<<<<<<<<<<< + * skipsolve[0] = result_dict.get("skipsolve", False) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(3, 144, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_auxviol[0]) = __pyx_t_8; + + /* "src/pyscipopt/benders.pxi":145 + * infeasible[0] = result_dict.get("infeasible", False) + * auxviol[0] = result_dict.get("auxviol", False) + * skipsolve[0] = result_dict.get("skipsolve", False) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(3, 145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + (__pyx_v_skipsolve[0]) = __pyx_t_8; + + /* "src/pyscipopt/benders.pxi":146 + * auxviol[0] = result_dict.get("auxviol", False) + * skipsolve[0] = result_dict.get("skipsolve", False) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_9 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_3); if (unlikely((__pyx_t_9 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(3, 146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + (__pyx_v_result[0]) = __pyx_t_9; + + /* "src/pyscipopt/benders.pxi":147 + * skipsolve[0] = result_dict.get("skipsolve", False) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersSolvesubconvex (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Bool onlyconvex, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":133 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersPresubsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint, SCIP_Bool* infeasible, SCIP_Bool* auxviol, SCIP_Bool* skipsolve, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersPresubsolve", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":149 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersSolvesubconvex (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Bool onlyconvex, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersSolvesubconvex(SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders, SCIP_SOL *__pyx_v_sol, int __pyx_v_probnumber, SCIP_Bool __pyx_v_onlyconvex, SCIP_Real *__pyx_v_objective, SCIP_RESULT *__pyx_v_result) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + PyObject *__pyx_v_solution = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + SCIP_Real __pyx_t_8; + SCIP_RESULT __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersSolvesubconvex", 0); + + /* "src/pyscipopt/benders.pxi":151 + * cdef SCIP_RETCODE PyBendersSolvesubconvex (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Bool onlyconvex, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * if sol == NULL: + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":152 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * if sol == NULL: + * solution = None + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":153 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + __pyx_t_2 = (__pyx_v_sol == NULL); + if (__pyx_t_2) { + + /* "src/pyscipopt/benders.pxi":154 + * PyBenders = bendersdata + * if sol == NULL: + * solution = None # <<<<<<<<<<<<<< + * else: + * solution = Solution.create(scip, sol) + */ + __Pyx_INCREF(Py_None); + __pyx_v_solution = Py_None; + + /* "src/pyscipopt/benders.pxi":153 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/benders.pxi":156 + * solution = None + * else: + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * result_dict = PyBenders.benderssolvesubconvex(solution, probnumber, onlyconvex) + * objective[0] = result_dict.get("objective", 1e+20) + */ + /*else*/ { + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/benders.pxi":157 + * else: + * solution = Solution.create(scip, sol) + * result_dict = PyBenders.benderssolvesubconvex(solution, probnumber, onlyconvex) # <<<<<<<<<<<<<< + * objective[0] = result_dict.get("objective", 1e+20) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_benderssolvesubconvex); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_probnumber); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_onlyconvex); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_v_solution, __pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 3+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":158 + * solution = Solution.create(scip, sol) + * result_dict = PyBenders.benderssolvesubconvex(solution, probnumber, onlyconvex) + * objective[0] = result_dict.get("objective", 1e+20) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(3, 158, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + (__pyx_v_objective[0]) = __pyx_t_8; + + /* "src/pyscipopt/benders.pxi":159 + * result_dict = PyBenders.benderssolvesubconvex(solution, probnumber, onlyconvex) + * objective[0] = result_dict.get("objective", 1e+20) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_9 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_3); if (unlikely((__pyx_t_9 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(3, 159, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + (__pyx_v_result[0]) = __pyx_t_9; + + /* "src/pyscipopt/benders.pxi":160 + * objective[0] = result_dict.get("objective", 1e+20) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersSolvesub (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":149 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersSolvesubconvex (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Bool onlyconvex, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersSolvesubconvex", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":162 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersSolvesub (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersSolvesub(SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders, SCIP_SOL *__pyx_v_sol, int __pyx_v_probnumber, SCIP_Real *__pyx_v_objective, SCIP_RESULT *__pyx_v_result) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + PyObject *__pyx_v_solution = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + SCIP_Real __pyx_t_7; + SCIP_RESULT __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersSolvesub", 0); + + /* "src/pyscipopt/benders.pxi":164 + * cdef SCIP_RETCODE PyBendersSolvesub (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * if sol == NULL: + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":165 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * if sol == NULL: + * solution = None + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":166 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + __pyx_t_2 = (__pyx_v_sol == NULL); + if (__pyx_t_2) { + + /* "src/pyscipopt/benders.pxi":167 + * PyBenders = bendersdata + * if sol == NULL: + * solution = None # <<<<<<<<<<<<<< + * else: + * solution = Solution.create(scip, sol) + */ + __Pyx_INCREF(Py_None); + __pyx_v_solution = Py_None; + + /* "src/pyscipopt/benders.pxi":166 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/benders.pxi":169 + * solution = None + * else: + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * result_dict = PyBenders.benderssolvesub(solution, probnumber) + * objective[0] = result_dict.get("objective", 1e+20) + */ + /*else*/ { + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/benders.pxi":170 + * else: + * solution = Solution.create(scip, sol) + * result_dict = PyBenders.benderssolvesub(solution, probnumber) # <<<<<<<<<<<<<< + * objective[0] = result_dict.get("objective", 1e+20) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_benderssolvesub); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_probnumber); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_v_solution, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":171 + * solution = Solution.create(scip, sol) + * result_dict = PyBenders.benderssolvesub(solution, probnumber) + * objective[0] = result_dict.get("objective", 1e+20) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_7 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(3, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + (__pyx_v_objective[0]) = __pyx_t_7; + + /* "src/pyscipopt/benders.pxi":172 + * result_dict = PyBenders.benderssolvesub(solution, probnumber) + * objective[0] = result_dict.get("objective", 1e+20) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_n_u_result, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_8 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_3); if (unlikely((__pyx_t_8 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(3, 172, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + (__pyx_v_result[0]) = __pyx_t_8; + + /* "src/pyscipopt/benders.pxi":173 + * objective[0] = result_dict.get("objective", 1e+20) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersPostsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":162 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersSolvesub (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Real* objective, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersSolvesub", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":175 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersPostsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, # <<<<<<<<<<<<<< + * SCIP_BENDERSENFOTYPE type, int* mergecands, int npriomergecands, int nmergecands, SCIP_Bool checkint, + * SCIP_Bool infeasible, SCIP_Bool* merged) noexcept with gil: + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersPostsolve(SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders, SCIP_SOL *__pyx_v_sol, SCIP_BENDERSENFOTYPE __pyx_v_type, int *__pyx_v_mergecands, int __pyx_v_npriomergecands, int __pyx_v_nmergecands, SCIP_Bool __pyx_v_checkint, SCIP_Bool __pyx_v_infeasible, SCIP_Bool *__pyx_v_merged) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + PyObject *__pyx_v_solution = NULL; + SCIP_BENDERSENFOTYPE __pyx_v_enfotype; + PyObject *__pyx_v_mergecandidates = NULL; + int __pyx_v_i; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + SCIP_Bool __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersPostsolve", 0); + + /* "src/pyscipopt/benders.pxi":179 + * SCIP_Bool infeasible, SCIP_Bool* merged) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * if sol == NULL: + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":180 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * if sol == NULL: + * solution = None + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":181 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + __pyx_t_2 = (__pyx_v_sol == NULL); + if (__pyx_t_2) { + + /* "src/pyscipopt/benders.pxi":182 + * PyBenders = bendersdata + * if sol == NULL: + * solution = None # <<<<<<<<<<<<<< + * else: + * solution = Solution.create(scip, sol) + */ + __Pyx_INCREF(Py_None); + __pyx_v_solution = Py_None; + + /* "src/pyscipopt/benders.pxi":181 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/benders.pxi":184 + * solution = None + * else: + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * enfotype = type + * mergecandidates = [] + */ + /*else*/ { + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/benders.pxi":185 + * else: + * solution = Solution.create(scip, sol) + * enfotype = type # <<<<<<<<<<<<<< + * mergecandidates = [] + * for i in range(nmergecands): + */ + __pyx_v_enfotype = __pyx_v_type; + + /* "src/pyscipopt/benders.pxi":186 + * solution = Solution.create(scip, sol) + * enfotype = type + * mergecandidates = [] # <<<<<<<<<<<<<< + * for i in range(nmergecands): + * mergecandidates.append(mergecands[i]) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_mergecandidates = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":187 + * enfotype = type + * mergecandidates = [] + * for i in range(nmergecands): # <<<<<<<<<<<<<< + * mergecandidates.append(mergecands[i]) + * result_dict = PyBenders.benderspostsolve(solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible) + */ + __pyx_t_3 = __pyx_v_nmergecands; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "src/pyscipopt/benders.pxi":188 + * mergecandidates = [] + * for i in range(nmergecands): + * mergecandidates.append(mergecands[i]) # <<<<<<<<<<<<<< + * result_dict = PyBenders.benderspostsolve(solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible) + * merged[0] = result_dict.get("merged", False) + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_mergecands[__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_mergecandidates, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(3, 188, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/benders.pxi":189 + * for i in range(nmergecands): + * mergecandidates.append(mergecands[i]) + * result_dict = PyBenders.benderspostsolve(solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible) # <<<<<<<<<<<<<< + * merged[0] = result_dict.get("merged", False) + * return SCIP_OKAY + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_benderspostsolve); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(__pyx_v_enfotype); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_npriomergecands); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyBool_FromLong(__pyx_v_checkint); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyBool_FromLong(__pyx_v_infeasible); if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = NULL; + __pyx_t_3 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_3 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[7] = {__pyx_t_12, __pyx_v_solution, __pyx_t_8, __pyx_v_mergecandidates, __pyx_t_9, __pyx_t_10, __pyx_t_11}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_3, 6+__pyx_t_3); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":190 + * mergecandidates.append(mergecands[i]) + * result_dict = PyBenders.benderspostsolve(solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible) + * merged[0] = result_dict.get("merged", False) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(3, 190, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + (__pyx_v_merged[0]) = __pyx_t_13; + + /* "src/pyscipopt/benders.pxi":191 + * result_dict = PyBenders.benderspostsolve(solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible) + * merged[0] = result_dict.get("merged", False) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBendersFreesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":175 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersPostsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, # <<<<<<<<<<<<<< + * SCIP_BENDERSENFOTYPE type, int* mergecands, int npriomergecands, int nmergecands, SCIP_Bool checkint, + * SCIP_Bool infeasible, SCIP_Bool* merged) noexcept with gil: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersPostsolve", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_mergecandidates); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":193 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersFreesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersFreesub(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders, int __pyx_v_probnumber) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersFreesub", 0); + + /* "src/pyscipopt/benders.pxi":195 + * cdef SCIP_RETCODE PyBendersFreesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyBenders.bendersfreesub(probnumber) + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":196 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyBenders.bendersfreesub(probnumber) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":197 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyBenders.bendersfreesub(probnumber) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersfreesub); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_probnumber); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":198 + * PyBenders = bendersdata + * PyBenders.bendersfreesub(probnumber) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * #TODO: Really need to ask about the passing and returning of variables + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":193 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBendersFreesub (SCIP* scip, SCIP_BENDERS* benders, int probnumber) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersFreesub", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benders.pxi":201 + * + * #TODO: Really need to ask about the passing and returning of variables + * cdef SCIP_RETCODE PyBendersGetvar (SCIP* scip, SCIP_BENDERS* benders, SCIP_VAR* var, SCIP_VAR** mappedvar, int probnumber) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBendersGetvar(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERS *__pyx_v_benders, SCIP_VAR *__pyx_v_var, SCIP_VAR **__pyx_v_mappedvar, int __pyx_v_probnumber) { + SCIP_BENDERSDATA *__pyx_v_bendersdata; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_PyBenders = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_PyVar = NULL; + PyObject *__pyx_v_result_dict = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_mappedvariable = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + SCIP_VAR *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBendersGetvar", 0); + + /* "src/pyscipopt/benders.pxi":203 + * cdef SCIP_RETCODE PyBendersGetvar (SCIP* scip, SCIP_BENDERS* benders, SCIP_VAR* var, SCIP_VAR** mappedvar, int probnumber) noexcept with gil: + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) # <<<<<<<<<<<<<< + * PyBenders = bendersdata + * PyVar = getPyVar(var) + */ + __pyx_v_bendersdata = SCIPbendersGetData(__pyx_v_benders); + + /* "src/pyscipopt/benders.pxi":204 + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata # <<<<<<<<<<<<<< + * PyVar = getPyVar(var) + * result_dict = PyBenders.bendersgetvar(PyVar, probnumber) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_bendersdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":205 + * bendersdata = SCIPbendersGetData(benders) + * PyBenders = bendersdata + * PyVar = getPyVar(var) # <<<<<<<<<<<<<< + * result_dict = PyBenders.bendersgetvar(PyVar, probnumber) + * mappedvariable = (result_dict.get("mappedvar", None)) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyVar(__pyx_v_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 205, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyVar = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":206 + * PyBenders = bendersdata + * PyVar = getPyVar(var) + * result_dict = PyBenders.bendersgetvar(PyVar, probnumber) # <<<<<<<<<<<<<< + * mappedvariable = (result_dict.get("mappedvar", None)) + * if mappedvariable is None: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenders), __pyx_n_s_bendersgetvar); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_probnumber); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, ((PyObject *)__pyx_v_PyVar), __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":207 + * PyVar = getPyVar(var) + * result_dict = PyBenders.bendersgetvar(PyVar, probnumber) + * mappedvariable = (result_dict.get("mappedvar", None)) # <<<<<<<<<<<<<< + * if mappedvariable is None: + * mappedvar[0] = NULL + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_mappedvariable = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benders.pxi":208 + * result_dict = PyBenders.bendersgetvar(PyVar, probnumber) + * mappedvariable = (result_dict.get("mappedvar", None)) + * if mappedvariable is None: # <<<<<<<<<<<<<< + * mappedvar[0] = NULL + * else: + */ + __pyx_t_6 = (((PyObject *)__pyx_v_mappedvariable) == Py_None); + if (__pyx_t_6) { + + /* "src/pyscipopt/benders.pxi":209 + * mappedvariable = (result_dict.get("mappedvar", None)) + * if mappedvariable is None: + * mappedvar[0] = NULL # <<<<<<<<<<<<<< + * else: + * mappedvar[0] = mappedvariable.scip_var + */ + (__pyx_v_mappedvar[0]) = NULL; + + /* "src/pyscipopt/benders.pxi":208 + * result_dict = PyBenders.bendersgetvar(PyVar, probnumber) + * mappedvariable = (result_dict.get("mappedvar", None)) + * if mappedvariable is None: # <<<<<<<<<<<<<< + * mappedvar[0] = NULL + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/benders.pxi":211 + * mappedvar[0] = NULL + * else: + * mappedvar[0] = mappedvariable.scip_var # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + /*else*/ { + __pyx_t_7 = __pyx_v_mappedvariable->scip_var; + (__pyx_v_mappedvar[0]) = __pyx_t_7; + } + __pyx_L3:; + + /* "src/pyscipopt/benders.pxi":212 + * else: + * mappedvar[0] = mappedvariable.scip_var + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benders.pxi":201 + * + * #TODO: Really need to ask about the passing and returning of variables + * cdef SCIP_RETCODE PyBendersGetvar (SCIP* scip, SCIP_BENDERS* benders, SCIP_VAR* var, SCIP_VAR** mappedvar, int probnumber) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSDATA* bendersdata + * bendersdata = SCIPbendersGetData(benders) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBendersGetvar", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenders); + __Pyx_XDECREF((PyObject *)__pyx_v_PyVar); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_XDECREF((PyObject *)__pyx_v_mappedvariable); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":8 + * cdef public str name + * + * def benderscutfree(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_1benderscutfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Benderscut_benderscutfree, "Benderscut.benderscutfree(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Benderscut_1benderscutfree = {"benderscutfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_1benderscutfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_benderscutfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_1benderscutfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("benderscutfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "benderscutfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_benderscutfree(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_benderscutfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":11 + * pass + * + * def benderscutinit(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_3benderscutinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Benderscut_2benderscutinit, "Benderscut.benderscutinit(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Benderscut_3benderscutinit = {"benderscutinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_3benderscutinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_2benderscutinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_3benderscutinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("benderscutinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "benderscutinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_2benderscutinit(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_2benderscutinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":14 + * pass + * + * def benderscutexit(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_5benderscutexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Benderscut_4benderscutexit, "Benderscut.benderscutexit(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Benderscut_5benderscutexit = {"benderscutexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_5benderscutexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_4benderscutexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_5benderscutexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("benderscutexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "benderscutexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_4benderscutexit(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_4benderscutexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":17 + * pass + * + * def benderscutinitsol(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_7benderscutinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Benderscut_6benderscutinitsol, "Benderscut.benderscutinitsol(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Benderscut_7benderscutinitsol = {"benderscutinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_7benderscutinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_6benderscutinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_7benderscutinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("benderscutinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "benderscutinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_6benderscutinitsol(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_6benderscutinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":20 + * pass + * + * def benderscutexitsol(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_9benderscutexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Benderscut_8benderscutexitsol, "Benderscut.benderscutexitsol(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Benderscut_9benderscutexitsol = {"benderscutexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_9benderscutexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_8benderscutexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_9benderscutexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("benderscutexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "benderscutexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_8benderscutexitsol(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_8benderscutexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":23 + * pass + * + * def benderscutexec(self, solution, probnumber, enfotype): # <<<<<<<<<<<<<< + * print("python error in benderscutexec: this method needs to be implemented") + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_11benderscutexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Benderscut_10benderscutexec, "Benderscut.benderscutexec(self, solution, probnumber, enfotype)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Benderscut_11benderscutexec = {"benderscutexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_11benderscutexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_10benderscutexec}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_11benderscutexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + CYTHON_UNUSED PyObject *__pyx_v_probnumber = 0; + CYTHON_UNUSED PyObject *__pyx_v_enfotype = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("benderscutexec (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_probnumber,&__pyx_n_s_enfotype,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(7, 23, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(7, 23, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderscutexec", 1, 3, 3, 1); __PYX_ERR(7, 23, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enfotype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(7, 23, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("benderscutexec", 1, 3, 3, 2); __PYX_ERR(7, 23, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "benderscutexec") < 0)) __PYX_ERR(7, 23, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_solution = values[0]; + __pyx_v_probnumber = values[1]; + __pyx_v_enfotype = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("benderscutexec", 1, 3, 3, __pyx_nargs); __PYX_ERR(7, 23, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benderscut.benderscutexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_10benderscutexec(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self), __pyx_v_solution, __pyx_v_probnumber, __pyx_v_enfotype); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_10benderscutexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_probnumber, CYTHON_UNUSED PyObject *__pyx_v_enfotype) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("benderscutexec", 1); + + /* "src/pyscipopt/benderscut.pxi":24 + * + * def benderscutexec(self, solution, probnumber, enfotype): + * print("python error in benderscutexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":25 + * def benderscutexec(self, solution, probnumber, enfotype): + * print("python error in benderscutexec: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBenderscutCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut) noexcept with gil: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 25, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/benderscut.pxi":23 + * pass + * + * def benderscutexec(self, solution, probnumber, enfotype): # <<<<<<<<<<<<<< + * print("python error in benderscutexec: this method needs to be implemented") + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benderscut.benderscutexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":4 + * #@brief Base class of the Benderscut Plugin + * cdef class Benderscut: + * cdef public Model model # <<<<<<<<<<<<<< + * cdef public Benders benders + * cdef public str name + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(7, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benderscut.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":5 + * cdef class Benderscut: + * cdef public Model model + * cdef public Benders benders # <<<<<<<<<<<<<< + * cdef public str name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_7benders___get__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_7benders___get__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->benders); + __pyx_r = ((PyObject *)__pyx_v_self->benders); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_7benders_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_7benders_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Benders))))) __PYX_ERR(7, 5, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->benders); + __Pyx_DECREF((PyObject *)__pyx_v_self->benders); + __pyx_v_self->benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benderscut.benders.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_7benders_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_7benders_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->benders); + __Pyx_DECREF((PyObject *)__pyx_v_self->benders); + __pyx_v_self->benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":6 + * cdef public Model model + * cdef public Benders benders + * cdef public str name # <<<<<<<<<<<<<< + * + * def benderscutfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_4name_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(PyUnicode_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_value))) __PYX_ERR(7, 6, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benderscut.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Benderscut_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_4name_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Benderscut_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Benderscut_12__reduce_cython__, "Benderscut.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Benderscut_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_12__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_12__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.benders, self.model, self.name) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->benders); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->benders); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->benders))) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_self->name)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.benders, self.model, self.name) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.benders, self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.benders is not None or self.model is not None or self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.benders, self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.benders is not None or self.model is not None or self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, None), state + */ + /*else*/ { + __pyx_t_4 = (((PyObject *)__pyx_v_self->benders) != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (((PyObject *)__pyx_v_self->model) != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->name != ((PyObject*)Py_None)); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.benders is not None or self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.benders is not None or self.model is not None or self.name is not None + * if use_setstate: + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Benderscut); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_95355963); + __Pyx_GIVEREF(__pyx_int_95355963); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_95355963)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.benders is not None or self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, None), state + * else: + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Benderscut__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Benderscut); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_95355963); + __Pyx_GIVEREF(__pyx_int_95355963); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_95355963)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Benderscut.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Benderscut__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Benderscut_14__setstate_cython__, "Benderscut.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Benderscut_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_14__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Benderscut_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Benderscut.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Benderscut_14__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Benderscut_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Benderscut__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Benderscut__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Benderscut__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Benderscut.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":27 + * return {} + * + * cdef SCIP_RETCODE PyBenderscutCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_BENDERS *__pyx_v_benders, CYTHON_UNUSED SCIP_BENDERSCUT *__pyx_v_benderscut) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/benderscut.pxi":28 + * + * cdef SCIP_RETCODE PyBenderscutCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBenderscutFree (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benderscut.pxi":27 + * return {} + * + * cdef SCIP_RETCODE PyBenderscutCopy (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":30 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutFree (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERSCUT *__pyx_v_benderscut) { + SCIP_BENDERSCUTDATA *__pyx_v_benderscutdata; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_PyBenderscut = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBenderscutFree", 0); + + /* "src/pyscipopt/benderscut.pxi":32 + * cdef SCIP_RETCODE PyBenderscutFree (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) # <<<<<<<<<<<<<< + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutfree() + */ + __pyx_v_benderscutdata = SCIPbenderscutGetData(__pyx_v_benderscut); + + /* "src/pyscipopt/benderscut.pxi":33 + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata # <<<<<<<<<<<<<< + * PyBenderscut.benderscutfree() + * Py_DECREF(PyBenderscut) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_benderscutdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenderscut = ((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":34 + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyBenderscut) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenderscut), __pyx_n_s_benderscutfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":35 + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutfree() + * Py_DECREF(PyBenderscut) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyBenderscut)); + + /* "src/pyscipopt/benderscut.pxi":36 + * PyBenderscut.benderscutfree() + * Py_DECREF(PyBenderscut) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBenderscutInit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benderscut.pxi":30 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutFree (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBenderscutFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenderscut); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":38 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutInit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERSCUT *__pyx_v_benderscut) { + SCIP_BENDERSCUTDATA *__pyx_v_benderscutdata; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_PyBenderscut = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBenderscutInit", 0); + + /* "src/pyscipopt/benderscut.pxi":40 + * cdef SCIP_RETCODE PyBenderscutInit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) # <<<<<<<<<<<<<< + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutinit() + */ + __pyx_v_benderscutdata = SCIPbenderscutGetData(__pyx_v_benderscut); + + /* "src/pyscipopt/benderscut.pxi":41 + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata # <<<<<<<<<<<<<< + * PyBenderscut.benderscutinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_benderscutdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenderscut = ((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":42 + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenderscut), __pyx_n_s_benderscutinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":43 + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBenderscutExit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benderscut.pxi":38 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutInit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBenderscutInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenderscut); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":45 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutExit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERSCUT *__pyx_v_benderscut) { + SCIP_BENDERSCUTDATA *__pyx_v_benderscutdata; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_PyBenderscut = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBenderscutExit", 0); + + /* "src/pyscipopt/benderscut.pxi":47 + * cdef SCIP_RETCODE PyBenderscutExit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) # <<<<<<<<<<<<<< + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutexit() + */ + __pyx_v_benderscutdata = SCIPbenderscutGetData(__pyx_v_benderscut); + + /* "src/pyscipopt/benderscut.pxi":48 + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata # <<<<<<<<<<<<<< + * PyBenderscut.benderscutexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_benderscutdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenderscut = ((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":49 + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenderscut), __pyx_n_s_benderscutexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":50 + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBenderscutInitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benderscut.pxi":45 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutExit (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBenderscutExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenderscut); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":52 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutInitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERSCUT *__pyx_v_benderscut) { + SCIP_BENDERSCUTDATA *__pyx_v_benderscutdata; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_PyBenderscut = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBenderscutInitsol", 0); + + /* "src/pyscipopt/benderscut.pxi":54 + * cdef SCIP_RETCODE PyBenderscutInitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) # <<<<<<<<<<<<<< + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutinitsol() + */ + __pyx_v_benderscutdata = SCIPbenderscutGetData(__pyx_v_benderscut); + + /* "src/pyscipopt/benderscut.pxi":55 + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata # <<<<<<<<<<<<<< + * PyBenderscut.benderscutinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_benderscutdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenderscut = ((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":56 + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenderscut), __pyx_n_s_benderscutinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":57 + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBenderscutExitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benderscut.pxi":52 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutInitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBenderscutInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenderscut); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":59 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutExitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BENDERSCUT *__pyx_v_benderscut) { + SCIP_BENDERSCUTDATA *__pyx_v_benderscutdata; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_PyBenderscut = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBenderscutExitsol", 0); + + /* "src/pyscipopt/benderscut.pxi":61 + * cdef SCIP_RETCODE PyBenderscutExitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) # <<<<<<<<<<<<<< + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutexitsol() + */ + __pyx_v_benderscutdata = SCIPbenderscutGetData(__pyx_v_benderscut); + + /* "src/pyscipopt/benderscut.pxi":62 + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata # <<<<<<<<<<<<<< + * PyBenderscut.benderscutexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_benderscutdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenderscut = ((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":63 + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenderscut), __pyx_n_s_benderscutexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":64 + * PyBenderscut = benderscutdata + * PyBenderscut.benderscutexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBenderscutExec (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut, SCIP_SOL* sol, int probnumber, SCIP_BENDERSENFOTYPE type, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benderscut.pxi":59 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutExitsol (SCIP* scip, SCIP_BENDERSCUT* benderscut) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBenderscutExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenderscut); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/benderscut.pxi":66 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutExec (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut, SCIP_SOL* sol, int probnumber, SCIP_BENDERSENFOTYPE type, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBenderscutExec(SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_BENDERS *__pyx_v_benders, SCIP_BENDERSCUT *__pyx_v_benderscut, SCIP_SOL *__pyx_v_sol, int __pyx_v_probnumber, SCIP_BENDERSENFOTYPE __pyx_v_type, SCIP_RESULT *__pyx_v_result) { + SCIP_BENDERSCUTDATA *__pyx_v_benderscutdata; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_PyBenderscut = NULL; + PyObject *__pyx_v_solution = NULL; + SCIP_BENDERSENFOTYPE __pyx_v_enfotype; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + SCIP_RESULT __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBenderscutExec", 0); + + /* "src/pyscipopt/benderscut.pxi":68 + * cdef SCIP_RETCODE PyBenderscutExec (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut, SCIP_SOL* sol, int probnumber, SCIP_BENDERSENFOTYPE type, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) # <<<<<<<<<<<<<< + * PyBenderscut = benderscutdata + * if sol == NULL: + */ + __pyx_v_benderscutdata = SCIPbenderscutGetData(__pyx_v_benderscut); + + /* "src/pyscipopt/benderscut.pxi":69 + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata # <<<<<<<<<<<<<< + * if sol == NULL: + * solution = None + */ + __pyx_t_1 = ((PyObject *)__pyx_v_benderscutdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBenderscut = ((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":70 + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + __pyx_t_2 = (__pyx_v_sol == NULL); + if (__pyx_t_2) { + + /* "src/pyscipopt/benderscut.pxi":71 + * PyBenderscut = benderscutdata + * if sol == NULL: + * solution = None # <<<<<<<<<<<<<< + * else: + * solution = Solution.create(scip, sol) + */ + __Pyx_INCREF(Py_None); + __pyx_v_solution = Py_None; + + /* "src/pyscipopt/benderscut.pxi":70 + * benderscutdata = SCIPbenderscutGetData(benderscut) + * PyBenderscut = benderscutdata + * if sol == NULL: # <<<<<<<<<<<<<< + * solution = None + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/benderscut.pxi":73 + * solution = None + * else: + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * enfotype = type + * result_dict = PyBenderscut.benderscutexec(solution, probnumber, enfotype) + */ + /*else*/ { + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/benderscut.pxi":74 + * else: + * solution = Solution.create(scip, sol) + * enfotype = type # <<<<<<<<<<<<<< + * result_dict = PyBenderscut.benderscutexec(solution, probnumber, enfotype) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_v_enfotype = __pyx_v_type; + + /* "src/pyscipopt/benderscut.pxi":75 + * solution = Solution.create(scip, sol) + * enfotype = type + * result_dict = PyBenderscut.benderscutexec(solution, probnumber, enfotype) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBenderscut), __pyx_n_s_benderscutexec); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_probnumber); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(__pyx_v_enfotype); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_v_solution, __pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 3+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/benderscut.pxi":76 + * enfotype = type + * result_dict = PyBenderscut.benderscutexec(solution, probnumber, enfotype) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(7, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_5)) __PYX_ERR(7, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_8 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_8 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(7, 76, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_8; + + /* "src/pyscipopt/benderscut.pxi":77 + * result_dict = PyBenderscut.benderscutexec(solution, probnumber, enfotype) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/benderscut.pxi":66 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBenderscutExec (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut, SCIP_SOL* sol, int probnumber, SCIP_BENDERSENFOTYPE type, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BENDERSCUTDATA* benderscutdata + * benderscutdata = SCIPbenderscutGetData(benderscut) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBenderscutExec", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBenderscut); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":6 + * cdef public Model model + * + * def branchfree(self): # <<<<<<<<<<<<<< + * '''frees memory of branching rule''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_1branchfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_branchfree, "Branchrule.branchfree(self)\nfrees memory of branching rule"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_1branchfree = {"branchfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_1branchfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_branchfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_1branchfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("branchfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "branchfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_branchfree(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_branchfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":10 + * pass + * + * def branchinit(self): # <<<<<<<<<<<<<< + * '''initializes branching rule''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_3branchinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_2branchinit, "Branchrule.branchinit(self)\ninitializes branching rule"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_3branchinit = {"branchinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_3branchinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_2branchinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_3branchinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("branchinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "branchinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_2branchinit(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_2branchinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":14 + * pass + * + * def branchexit(self): # <<<<<<<<<<<<<< + * '''deinitializes branching rule''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_5branchexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_4branchexit, "Branchrule.branchexit(self)\ndeinitializes branching rule"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_5branchexit = {"branchexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_5branchexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_4branchexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_5branchexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("branchexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "branchexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_4branchexit(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_4branchexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":18 + * pass + * + * def branchinitsol(self): # <<<<<<<<<<<<<< + * '''informs branching rule that the branch and bound process is being started ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_7branchinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_6branchinitsol, "Branchrule.branchinitsol(self)\ninforms branching rule that the branch and bound process is being started "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_7branchinitsol = {"branchinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_7branchinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_6branchinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_7branchinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("branchinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "branchinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_6branchinitsol(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_6branchinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":22 + * pass + * + * def branchexitsol(self): # <<<<<<<<<<<<<< + * '''informs branching rule that the branch and bound process data is being freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_9branchexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_8branchexitsol, "Branchrule.branchexitsol(self)\ninforms branching rule that the branch and bound process data is being freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_9branchexitsol = {"branchexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_9branchexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_8branchexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_9branchexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("branchexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "branchexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_8branchexitsol(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_8branchexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":26 + * pass + * + * def branchexeclp(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for fractional LP solution''' + * raise NotImplementedError("branchexeclp() is a fundamental callback and should be implemented in the derived " + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_11branchexeclp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_10branchexeclp, "Branchrule.branchexeclp(self, allowaddcons)\nexecutes branching rule for fractional LP solution"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_11branchexeclp = {"branchexeclp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_11branchexeclp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_10branchexeclp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_11branchexeclp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_allowaddcons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchexeclp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_allowaddcons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allowaddcons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(8, 26, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "branchexeclp") < 0)) __PYX_ERR(8, 26, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_allowaddcons = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("branchexeclp", 1, 1, 1, __pyx_nargs); __PYX_ERR(8, 26, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.branchexeclp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_10branchexeclp(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self), __pyx_v_allowaddcons); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_10branchexeclp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_allowaddcons) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("branchexeclp", 1); + + /* "src/pyscipopt/branchrule.pxi":28 + * def branchexeclp(self, allowaddcons): + * '''executes branching rule for fractional LP solution''' + * raise NotImplementedError("branchexeclp() is a fundamental callback and should be implemented in the derived " # <<<<<<<<<<<<<< + * "class") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(8, 28, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":26 + * pass + * + * def branchexeclp(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for fractional LP solution''' + * raise NotImplementedError("branchexeclp() is a fundamental callback and should be implemented in the derived " + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.branchexeclp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":31 + * "class") + * + * def branchexecext(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for external branching candidates ''' + * raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_13branchexecext(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_12branchexecext, "Branchrule.branchexecext(self, allowaddcons)\nexecutes branching rule for external branching candidates "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_13branchexecext = {"branchexecext", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_13branchexecext, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_12branchexecext}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_13branchexecext(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_allowaddcons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchexecext (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_allowaddcons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allowaddcons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(8, 31, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "branchexecext") < 0)) __PYX_ERR(8, 31, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_allowaddcons = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("branchexecext", 1, 1, 1, __pyx_nargs); __PYX_ERR(8, 31, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.branchexecext", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_12branchexecext(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self), __pyx_v_allowaddcons); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_12branchexecext(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_allowaddcons) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("branchexecext", 1); + + /* "src/pyscipopt/branchrule.pxi":33 + * def branchexecext(self, allowaddcons): + * '''executes branching rule for external branching candidates ''' + * raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") # <<<<<<<<<<<<<< + * + * def branchexecps(self, allowaddcons): + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(8, 33, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":31 + * "class") + * + * def branchexecext(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for external branching candidates ''' + * raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.branchexecext", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":35 + * raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") + * + * def branchexecps(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for not completely fixed pseudo solution ''' + * # this method needs to be implemented by the user + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_15branchexecps(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_14branchexecps, "Branchrule.branchexecps(self, allowaddcons)\nexecutes branching rule for not completely fixed pseudo solution "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_15branchexecps = {"branchexecps", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_15branchexecps, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_14branchexecps}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_15branchexecps(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_allowaddcons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchexecps (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_allowaddcons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allowaddcons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(8, 35, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "branchexecps") < 0)) __PYX_ERR(8, 35, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_allowaddcons = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("branchexecps", 1, 1, 1, __pyx_nargs); __PYX_ERR(8, 35, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.branchexecps", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_14branchexecps(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self), __pyx_v_allowaddcons); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_14branchexecps(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_allowaddcons) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("branchexecps", 1); + + /* "src/pyscipopt/branchrule.pxi":38 + * '''executes branching rule for not completely fixed pseudo solution ''' + * # this method needs to be implemented by the user + * raise NotImplementedError("branchexecps() is a fundamental callback and should be implemented in the derived class") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(8, 38, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":35 + * raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") + * + * def branchexecps(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for not completely fixed pseudo solution ''' + * # this method needs to be implemented by the user + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.branchexecps", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":4 + * #@brief Base class of the Branchrule Plugin + * cdef class Branchrule: + * cdef public Model model # <<<<<<<<<<<<<< + * + * def branchfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Branchrule_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Branchrule_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Branchrule_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(8, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Branchrule_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Branchrule_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Branchrule_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_16__reduce_cython__, "Branchrule.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_16__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_16__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_16__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, None), state + */ + /*else*/ { + __pyx_t_2 = (((PyObject *)__pyx_v_self->model) != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None + * if use_setstate: + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Branchrule); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, None), state + * else: + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Branchrule__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Branchrule); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Branchrule__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Branchrule_18__setstate_cython__, "Branchrule.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Branchrule_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_18__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Branchrule_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Branchrule_18__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Branchrule_18__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Branchrule__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Branchrule__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Branchrule__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Branchrule.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":42 + * + * + * cdef SCIP_RETCODE PyBranchruleCopy (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_BRANCHRULE *__pyx_v_branchrule) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/branchrule.pxi":43 + * + * cdef SCIP_RETCODE PyBranchruleCopy (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBranchruleFree (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":42 + * + * + * cdef SCIP_RETCODE PyBranchruleCopy (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":45 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleFree (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BRANCHRULE *__pyx_v_branchrule) { + SCIP_BRANCHRULEDATA *__pyx_v_branchruledata; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_PyBranchrule = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBranchruleFree", 0); + + /* "src/pyscipopt/branchrule.pxi":47 + * cdef SCIP_RETCODE PyBranchruleFree (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) # <<<<<<<<<<<<<< + * PyBranchrule = branchruledata + * PyBranchrule.branchfree() + */ + __pyx_v_branchruledata = SCIPbranchruleGetData(__pyx_v_branchrule); + + /* "src/pyscipopt/branchrule.pxi":48 + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata # <<<<<<<<<<<<<< + * PyBranchrule.branchfree() + * Py_DECREF(PyBranchrule) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_branchruledata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBranchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":49 + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata + * PyBranchrule.branchfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyBranchrule) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBranchrule), __pyx_n_s_branchfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":50 + * PyBranchrule = branchruledata + * PyBranchrule.branchfree() + * Py_DECREF(PyBranchrule) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyBranchrule)); + + /* "src/pyscipopt/branchrule.pxi":51 + * PyBranchrule.branchfree() + * Py_DECREF(PyBranchrule) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBranchruleInit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":45 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleFree (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBranchruleFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBranchrule); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":53 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleInit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BRANCHRULE *__pyx_v_branchrule) { + SCIP_BRANCHRULEDATA *__pyx_v_branchruledata; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_PyBranchrule = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBranchruleInit", 0); + + /* "src/pyscipopt/branchrule.pxi":55 + * cdef SCIP_RETCODE PyBranchruleInit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) # <<<<<<<<<<<<<< + * PyBranchrule = branchruledata + * PyBranchrule.branchinit() + */ + __pyx_v_branchruledata = SCIPbranchruleGetData(__pyx_v_branchrule); + + /* "src/pyscipopt/branchrule.pxi":56 + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata # <<<<<<<<<<<<<< + * PyBranchrule.branchinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_branchruledata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBranchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":57 + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata + * PyBranchrule.branchinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBranchrule), __pyx_n_s_branchinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":58 + * PyBranchrule = branchruledata + * PyBranchrule.branchinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBranchruleExit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":53 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleInit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBranchruleInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBranchrule); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":60 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BRANCHRULE *__pyx_v_branchrule) { + SCIP_BRANCHRULEDATA *__pyx_v_branchruledata; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_PyBranchrule = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBranchruleExit", 0); + + /* "src/pyscipopt/branchrule.pxi":62 + * cdef SCIP_RETCODE PyBranchruleExit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) # <<<<<<<<<<<<<< + * PyBranchrule = branchruledata + * PyBranchrule.branchexit() + */ + __pyx_v_branchruledata = SCIPbranchruleGetData(__pyx_v_branchrule); + + /* "src/pyscipopt/branchrule.pxi":63 + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata # <<<<<<<<<<<<<< + * PyBranchrule.branchexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_branchruledata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBranchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":64 + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata + * PyBranchrule.branchexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBranchrule), __pyx_n_s_branchexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":65 + * PyBranchrule = branchruledata + * PyBranchrule.branchexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBranchruleInitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":60 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExit (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBranchruleExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBranchrule); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":67 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleInitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BRANCHRULE *__pyx_v_branchrule) { + SCIP_BRANCHRULEDATA *__pyx_v_branchruledata; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_PyBranchrule = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBranchruleInitsol", 0); + + /* "src/pyscipopt/branchrule.pxi":69 + * cdef SCIP_RETCODE PyBranchruleInitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) # <<<<<<<<<<<<<< + * PyBranchrule = branchruledata + * PyBranchrule.branchinitsol() + */ + __pyx_v_branchruledata = SCIPbranchruleGetData(__pyx_v_branchrule); + + /* "src/pyscipopt/branchrule.pxi":70 + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata # <<<<<<<<<<<<<< + * PyBranchrule.branchinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_branchruledata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBranchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":71 + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata + * PyBranchrule.branchinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBranchrule), __pyx_n_s_branchinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":72 + * PyBranchrule = branchruledata + * PyBranchrule.branchinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBranchruleExitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":67 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleInitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBranchruleInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBranchrule); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":74 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BRANCHRULE *__pyx_v_branchrule) { + SCIP_BRANCHRULEDATA *__pyx_v_branchruledata; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_PyBranchrule = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBranchruleExitsol", 0); + + /* "src/pyscipopt/branchrule.pxi":76 + * cdef SCIP_RETCODE PyBranchruleExitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) # <<<<<<<<<<<<<< + * PyBranchrule = branchruledata + * PyBranchrule.branchexitsol() + */ + __pyx_v_branchruledata = SCIPbranchruleGetData(__pyx_v_branchrule); + + /* "src/pyscipopt/branchrule.pxi":77 + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata # <<<<<<<<<<<<<< + * PyBranchrule.branchexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_branchruledata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBranchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":78 + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata + * PyBranchrule.branchexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBranchrule), __pyx_n_s_branchexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":79 + * PyBranchrule = branchruledata + * PyBranchrule.branchexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBranchruleExeclp (SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":74 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExitsol (SCIP* scip, SCIP_BRANCHRULE* branchrule) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBranchruleExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBranchrule); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":81 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExeclp (SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExeclp(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BRANCHRULE *__pyx_v_branchrule, SCIP_Bool __pyx_v_allowaddcons, SCIP_RESULT *__pyx_v_result) { + SCIP_BRANCHRULEDATA *__pyx_v_branchruledata; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_PyBranchrule = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + SCIP_RESULT __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBranchruleExeclp", 0); + + /* "src/pyscipopt/branchrule.pxi":83 + * cdef SCIP_RETCODE PyBranchruleExeclp (SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) # <<<<<<<<<<<<<< + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexeclp(allowaddcons) + */ + __pyx_v_branchruledata = SCIPbranchruleGetData(__pyx_v_branchrule); + + /* "src/pyscipopt/branchrule.pxi":84 + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata # <<<<<<<<<<<<<< + * result_dict = PyBranchrule.branchexeclp(allowaddcons) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_branchruledata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBranchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":85 + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexeclp(allowaddcons) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBranchrule), __pyx_n_s_branchexeclp); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_allowaddcons); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":86 + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexeclp(allowaddcons) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_6 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_6 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(8, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_6; + + /* "src/pyscipopt/branchrule.pxi":87 + * result_dict = PyBranchrule.branchexeclp(allowaddcons) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBranchruleExecext(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":81 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExeclp (SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBranchruleExeclp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBranchrule); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":89 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExecext(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExecext(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BRANCHRULE *__pyx_v_branchrule, SCIP_Bool __pyx_v_allowaddcons, SCIP_RESULT *__pyx_v_result) { + SCIP_BRANCHRULEDATA *__pyx_v_branchruledata; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_PyBranchrule = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + SCIP_RESULT __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBranchruleExecext", 0); + + /* "src/pyscipopt/branchrule.pxi":91 + * cdef SCIP_RETCODE PyBranchruleExecext(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) # <<<<<<<<<<<<<< + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexecext(allowaddcons) + */ + __pyx_v_branchruledata = SCIPbranchruleGetData(__pyx_v_branchrule); + + /* "src/pyscipopt/branchrule.pxi":92 + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata # <<<<<<<<<<<<<< + * result_dict = PyBranchrule.branchexecext(allowaddcons) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_branchruledata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBranchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":93 + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexecext(allowaddcons) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBranchrule), __pyx_n_s_branchexecext); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_allowaddcons); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":94 + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexecext(allowaddcons) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_6 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_6 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(8, 94, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_6; + + /* "src/pyscipopt/branchrule.pxi":95 + * result_dict = PyBranchrule.branchexecext(allowaddcons) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyBranchruleExecps(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":89 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExecext(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBranchruleExecext", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBranchrule); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/branchrule.pxi":97 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExecps(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyBranchruleExecps(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_BRANCHRULE *__pyx_v_branchrule, SCIP_Bool __pyx_v_allowaddcons, SCIP_RESULT *__pyx_v_result) { + SCIP_BRANCHRULEDATA *__pyx_v_branchruledata; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_PyBranchrule = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + SCIP_RESULT __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyBranchruleExecps", 0); + + /* "src/pyscipopt/branchrule.pxi":99 + * cdef SCIP_RETCODE PyBranchruleExecps(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) # <<<<<<<<<<<<<< + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexecps(allowaddcons) + */ + __pyx_v_branchruledata = SCIPbranchruleGetData(__pyx_v_branchrule); + + /* "src/pyscipopt/branchrule.pxi":100 + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata # <<<<<<<<<<<<<< + * result_dict = PyBranchrule.branchexecps(allowaddcons) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_branchruledata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyBranchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":101 + * branchruledata = SCIPbranchruleGetData(branchrule) + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexecps(allowaddcons) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyBranchrule), __pyx_n_s_branchexecps); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_allowaddcons); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/branchrule.pxi":102 + * PyBranchrule = branchruledata + * result_dict = PyBranchrule.branchexecps(allowaddcons) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_6 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_6 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(8, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_6; + + /* "src/pyscipopt/branchrule.pxi":103 + * result_dict = PyBranchrule.branchexecps(allowaddcons) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/branchrule.pxi":97 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyBranchruleExecps(SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_BRANCHRULEDATA* branchruledata + * branchruledata = SCIPbranchruleGetData(branchrule) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyBranchruleExecps", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyBranchrule); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":8 + * cdef public str name + * + * def consfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_1consfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_consfree, "Conshdlr.consfree(self)\ncalls destructor and frees memory of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_1consfree = {"consfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_1consfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_consfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_1consfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("consfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "consfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_consfree(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_consfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":12 + * pass + * + * def consinit(self, constraints): # <<<<<<<<<<<<<< + * '''calls initialization method of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_3consinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_2consinit, "Conshdlr.consinit(self, constraints)\ncalls initialization method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_3consinit = {"consinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_3consinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_2consinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_3consinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 12, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consinit") < 0)) __PYX_ERR(9, 12, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraints = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consinit", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 12, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consinit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_2consinit(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_2consinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":16 + * pass + * + * def consexit(self, constraints): # <<<<<<<<<<<<<< + * '''calls exit method of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_5consexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_4consexit, "Conshdlr.consexit(self, constraints)\ncalls exit method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_5consexit = {"consexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_5consexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_4consexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_5consexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consexit") < 0)) __PYX_ERR(9, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraints = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consexit", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consexit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_4consexit(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_4consexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":20 + * pass + * + * def consinitpre(self, constraints): # <<<<<<<<<<<<<< + * '''informs constraint handler that the presolving process is being started ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_7consinitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_6consinitpre, "Conshdlr.consinitpre(self, constraints)\ninforms constraint handler that the presolving process is being started "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_7consinitpre = {"consinitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_7consinitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_6consinitpre}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_7consinitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consinitpre (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 20, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consinitpre") < 0)) __PYX_ERR(9, 20, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraints = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consinitpre", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 20, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consinitpre", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_6consinitpre(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_6consinitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consinitpre", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":24 + * pass + * + * def consexitpre(self, constraints): # <<<<<<<<<<<<<< + * '''informs constraint handler that the presolving is finished ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_9consexitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_8consexitpre, "Conshdlr.consexitpre(self, constraints)\ninforms constraint handler that the presolving is finished "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_9consexitpre = {"consexitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_9consexitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_8consexitpre}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_9consexitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consexitpre (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 24, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consexitpre") < 0)) __PYX_ERR(9, 24, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraints = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consexitpre", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 24, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consexitpre", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_8consexitpre(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_8consexitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consexitpre", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":28 + * pass + * + * def consinitsol(self, constraints): # <<<<<<<<<<<<<< + * '''informs constraint handler that the branch and bound process is being started ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_11consinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_10consinitsol, "Conshdlr.consinitsol(self, constraints)\ninforms constraint handler that the branch and bound process is being started "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_11consinitsol = {"consinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_11consinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_10consinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_11consinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 28, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consinitsol") < 0)) __PYX_ERR(9, 28, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraints = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consinitsol", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 28, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consinitsol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_10consinitsol(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_10consinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":32 + * pass + * + * def consexitsol(self, constraints, restart): # <<<<<<<<<<<<<< + * '''informs constraint handler that the branch and bound process data is being freed ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_13consexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_12consexitsol, "Conshdlr.consexitsol(self, constraints, restart)\ninforms constraint handler that the branch and bound process data is being freed "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_13consexitsol = {"consexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_13consexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_12consexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_13consexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_restart = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,&__pyx_n_s_restart,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 32, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_restart)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 32, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consexitsol", 1, 2, 2, 1); __PYX_ERR(9, 32, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consexitsol") < 0)) __PYX_ERR(9, 32, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_constraints = values[0]; + __pyx_v_restart = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consexitsol", 1, 2, 2, __pyx_nargs); __PYX_ERR(9, 32, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consexitsol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_12consexitsol(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints, __pyx_v_restart); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_12consexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_restart) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":36 + * pass + * + * def consdelete(self, constraint): # <<<<<<<<<<<<<< + * '''sets method of constraint handler to free specific constraint data ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_15consdelete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_14consdelete, "Conshdlr.consdelete(self, constraint)\nsets method of constraint handler to free specific constraint data "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_15consdelete = {"consdelete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_15consdelete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_14consdelete}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_15consdelete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consdelete (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 36, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consdelete") < 0)) __PYX_ERR(9, 36, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consdelete", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 36, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consdelete", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_14consdelete(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_14consdelete(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consdelete", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":40 + * pass + * + * def constrans(self, sourceconstraint): # <<<<<<<<<<<<<< + * '''sets method of constraint handler to transform constraint data into data belonging to the transformed problem ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_17constrans(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_16constrans, "Conshdlr.constrans(self, sourceconstraint)\nsets method of constraint handler to transform constraint data into data belonging to the transformed problem "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_17constrans = {"constrans", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_17constrans, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_16constrans}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_17constrans(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_sourceconstraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("constrans (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sourceconstraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sourceconstraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 40, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "constrans") < 0)) __PYX_ERR(9, 40, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_sourceconstraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("constrans", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 40, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.constrans", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_16constrans(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_sourceconstraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_16constrans(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_sourceconstraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("constrans", 1); + + /* "src/pyscipopt/conshdlr.pxi":42 + * def constrans(self, sourceconstraint): + * '''sets method of constraint handler to transform constraint data into data belonging to the transformed problem ''' + * return {} # <<<<<<<<<<<<<< + * + * def consinitlp(self, constraints): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":40 + * pass + * + * def constrans(self, sourceconstraint): # <<<<<<<<<<<<<< + * '''sets method of constraint handler to transform constraint data into data belonging to the transformed problem ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.constrans", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":44 + * return {} + * + * def consinitlp(self, constraints): # <<<<<<<<<<<<<< + * '''calls LP initialization method of constraint handler to separate all initial active constraints ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_19consinitlp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_18consinitlp, "Conshdlr.consinitlp(self, constraints)\ncalls LP initialization method of constraint handler to separate all initial active constraints "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_19consinitlp = {"consinitlp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_19consinitlp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_18consinitlp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_19consinitlp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consinitlp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 44, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consinitlp") < 0)) __PYX_ERR(9, 44, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraints = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consinitlp", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 44, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consinitlp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_18consinitlp(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_18consinitlp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("consinitlp", 1); + + /* "src/pyscipopt/conshdlr.pxi":46 + * def consinitlp(self, constraints): + * '''calls LP initialization method of constraint handler to separate all initial active constraints ''' + * return {} # <<<<<<<<<<<<<< + * + * def conssepalp(self, constraints, nusefulconss): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":44 + * return {} + * + * def consinitlp(self, constraints): # <<<<<<<<<<<<<< + * '''calls LP initialization method of constraint handler to separate all initial active constraints ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consinitlp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":48 + * return {} + * + * def conssepalp(self, constraints, nusefulconss): # <<<<<<<<<<<<<< + * '''calls separator method of constraint handler to separate LP solution ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_21conssepalp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_20conssepalp, "Conshdlr.conssepalp(self, constraints, nusefulconss)\ncalls separator method of constraint handler to separate LP solution "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_21conssepalp = {"conssepalp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_21conssepalp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_20conssepalp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_21conssepalp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_nusefulconss = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("conssepalp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,&__pyx_n_s_nusefulconss,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 48, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nusefulconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 48, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conssepalp", 1, 2, 2, 1); __PYX_ERR(9, 48, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "conssepalp") < 0)) __PYX_ERR(9, 48, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_constraints = values[0]; + __pyx_v_nusefulconss = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("conssepalp", 1, 2, 2, __pyx_nargs); __PYX_ERR(9, 48, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conssepalp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_20conssepalp(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints, __pyx_v_nusefulconss); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_20conssepalp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("conssepalp", 1); + + /* "src/pyscipopt/conshdlr.pxi":50 + * def conssepalp(self, constraints, nusefulconss): + * '''calls separator method of constraint handler to separate LP solution ''' + * return {} # <<<<<<<<<<<<<< + * + * def conssepasol(self, constraints, nusefulconss, solution): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 50, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":48 + * return {} + * + * def conssepalp(self, constraints, nusefulconss): # <<<<<<<<<<<<<< + * '''calls separator method of constraint handler to separate LP solution ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conssepalp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":52 + * return {} + * + * def conssepasol(self, constraints, nusefulconss, solution): # <<<<<<<<<<<<<< + * '''calls separator method of constraint handler to separate given primal solution ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_23conssepasol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_22conssepasol, "Conshdlr.conssepasol(self, constraints, nusefulconss, solution)\ncalls separator method of constraint handler to separate given primal solution "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_23conssepasol = {"conssepasol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_23conssepasol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_22conssepasol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_23conssepasol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_nusefulconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("conssepasol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,&__pyx_n_s_nusefulconss,&__pyx_n_s_solution,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 52, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nusefulconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 52, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conssepasol", 1, 3, 3, 1); __PYX_ERR(9, 52, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 52, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conssepasol", 1, 3, 3, 2); __PYX_ERR(9, 52, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "conssepasol") < 0)) __PYX_ERR(9, 52, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_constraints = values[0]; + __pyx_v_nusefulconss = values[1]; + __pyx_v_solution = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("conssepasol", 1, 3, 3, __pyx_nargs); __PYX_ERR(9, 52, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conssepasol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_22conssepasol(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints, __pyx_v_nusefulconss, __pyx_v_solution); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_22conssepasol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_solution) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("conssepasol", 1); + + /* "src/pyscipopt/conshdlr.pxi":54 + * def conssepasol(self, constraints, nusefulconss, solution): + * '''calls separator method of constraint handler to separate given primal solution ''' + * return {} # <<<<<<<<<<<<<< + * + * def consenfolp(self, constraints, nusefulconss, solinfeasible): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":52 + * return {} + * + * def conssepasol(self, constraints, nusefulconss, solution): # <<<<<<<<<<<<<< + * '''calls separator method of constraint handler to separate given primal solution ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conssepasol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":56 + * return {} + * + * def consenfolp(self, constraints, nusefulconss, solinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for LP solution for all constraints added''' + * print("python error in consenfolp: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_25consenfolp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_24consenfolp, "Conshdlr.consenfolp(self, constraints, nusefulconss, solinfeasible)\ncalls enforcing method of constraint handler for LP solution for all constraints added"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_25consenfolp = {"consenfolp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_25consenfolp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_24consenfolp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_25consenfolp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_nusefulconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_solinfeasible = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consenfolp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,&__pyx_n_s_nusefulconss,&__pyx_n_s_solinfeasible,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 56, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nusefulconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 56, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consenfolp", 1, 3, 3, 1); __PYX_ERR(9, 56, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solinfeasible)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 56, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consenfolp", 1, 3, 3, 2); __PYX_ERR(9, 56, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consenfolp") < 0)) __PYX_ERR(9, 56, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_constraints = values[0]; + __pyx_v_nusefulconss = values[1]; + __pyx_v_solinfeasible = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consenfolp", 1, 3, 3, __pyx_nargs); __PYX_ERR(9, 56, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consenfolp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_24consenfolp(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints, __pyx_v_nusefulconss, __pyx_v_solinfeasible); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_24consenfolp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_solinfeasible) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("consenfolp", 1); + + /* "src/pyscipopt/conshdlr.pxi":58 + * def consenfolp(self, constraints, nusefulconss, solinfeasible): + * '''calls enforcing method of constraint handler for LP solution for all constraints added''' + * print("python error in consenfolp: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":59 + * '''calls enforcing method of constraint handler for LP solution for all constraints added''' + * print("python error in consenfolp: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * def consenforelax(self, solution, constraints, nusefulconss, solinfeasible): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":56 + * return {} + * + * def consenfolp(self, constraints, nusefulconss, solinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for LP solution for all constraints added''' + * print("python error in consenfolp: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consenfolp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":61 + * return {} + * + * def consenforelax(self, solution, constraints, nusefulconss, solinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for a relaxation solution for all constraints added''' + * print("python error in consenforelax: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_27consenforelax(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_26consenforelax, "Conshdlr.consenforelax(self, solution, constraints, nusefulconss, solinfeasible)\ncalls enforcing method of constraint handler for a relaxation solution for all constraints added"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_27consenforelax = {"consenforelax", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_27consenforelax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_26consenforelax}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_27consenforelax(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_nusefulconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_solinfeasible = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consenforelax (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_constraints,&__pyx_n_s_nusefulconss,&__pyx_n_s_solinfeasible,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 61, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 61, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consenforelax", 1, 4, 4, 1); __PYX_ERR(9, 61, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nusefulconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 61, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consenforelax", 1, 4, 4, 2); __PYX_ERR(9, 61, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solinfeasible)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 61, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consenforelax", 1, 4, 4, 3); __PYX_ERR(9, 61, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consenforelax") < 0)) __PYX_ERR(9, 61, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + } + __pyx_v_solution = values[0]; + __pyx_v_constraints = values[1]; + __pyx_v_nusefulconss = values[2]; + __pyx_v_solinfeasible = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consenforelax", 1, 4, 4, __pyx_nargs); __PYX_ERR(9, 61, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consenforelax", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_26consenforelax(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_solution, __pyx_v_constraints, __pyx_v_nusefulconss, __pyx_v_solinfeasible); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_26consenforelax(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_solinfeasible) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("consenforelax", 1); + + /* "src/pyscipopt/conshdlr.pxi":63 + * def consenforelax(self, solution, constraints, nusefulconss, solinfeasible): + * '''calls enforcing method of constraint handler for a relaxation solution for all constraints added''' + * print("python error in consenforelax: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":64 + * '''calls enforcing method of constraint handler for a relaxation solution for all constraints added''' + * print("python error in consenforelax: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":61 + * return {} + * + * def consenforelax(self, solution, constraints, nusefulconss, solinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for a relaxation solution for all constraints added''' + * print("python error in consenforelax: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consenforelax", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":66 + * return {} + * + * def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for pseudo solution for all constraints added''' + * print("python error in consenfops: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_29consenfops(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_28consenfops, "Conshdlr.consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible)\ncalls enforcing method of constraint handler for pseudo solution for all constraints added"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_29consenfops = {"consenfops", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_29consenfops, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_28consenfops}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_29consenfops(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_nusefulconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_solinfeasible = 0; + CYTHON_UNUSED PyObject *__pyx_v_objinfeasible = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consenfops (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,&__pyx_n_s_nusefulconss,&__pyx_n_s_solinfeasible,&__pyx_n_s_objinfeasible,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 66, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nusefulconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 66, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consenfops", 1, 4, 4, 1); __PYX_ERR(9, 66, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solinfeasible)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 66, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consenfops", 1, 4, 4, 2); __PYX_ERR(9, 66, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_objinfeasible)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 66, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consenfops", 1, 4, 4, 3); __PYX_ERR(9, 66, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consenfops") < 0)) __PYX_ERR(9, 66, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + } + __pyx_v_constraints = values[0]; + __pyx_v_nusefulconss = values[1]; + __pyx_v_solinfeasible = values[2]; + __pyx_v_objinfeasible = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consenfops", 1, 4, 4, __pyx_nargs); __PYX_ERR(9, 66, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consenfops", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_28consenfops(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints, __pyx_v_nusefulconss, __pyx_v_solinfeasible, __pyx_v_objinfeasible); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_28consenfops(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_solinfeasible, CYTHON_UNUSED PyObject *__pyx_v_objinfeasible) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("consenfops", 1); + + /* "src/pyscipopt/conshdlr.pxi":68 + * def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible): + * '''calls enforcing method of constraint handler for pseudo solution for all constraints added''' + * print("python error in consenfops: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":69 + * '''calls enforcing method of constraint handler for pseudo solution for all constraints added''' + * print("python error in consenfops: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":66 + * return {} + * + * def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for pseudo solution for all constraints added''' + * print("python error in consenfops: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consenfops", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":71 + * return {} + * + * def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely): # <<<<<<<<<<<<<< + * '''calls feasibility check method of constraint handler ''' + * print("python error in conscheck: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_31conscheck(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_30conscheck, "Conshdlr.conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely)\ncalls feasibility check method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_31conscheck = {"conscheck", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_31conscheck, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_30conscheck}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_31conscheck(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + CYTHON_UNUSED PyObject *__pyx_v_checkintegrality = 0; + CYTHON_UNUSED PyObject *__pyx_v_checklprows = 0; + CYTHON_UNUSED PyObject *__pyx_v_printreason = 0; + CYTHON_UNUSED PyObject *__pyx_v_completely = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[6] = {0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("conscheck (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,&__pyx_n_s_solution,&__pyx_n_s_checkintegrality,&__pyx_n_s_checklprows,&__pyx_n_s_printreason,&__pyx_n_s_completely,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 71, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 71, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conscheck", 1, 6, 6, 1); __PYX_ERR(9, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checkintegrality)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 71, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conscheck", 1, 6, 6, 2); __PYX_ERR(9, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checklprows)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 71, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conscheck", 1, 6, 6, 3); __PYX_ERR(9, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_printreason)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 71, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conscheck", 1, 6, 6, 4); __PYX_ERR(9, 71, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_completely)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[5]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 71, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conscheck", 1, 6, 6, 5); __PYX_ERR(9, 71, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "conscheck") < 0)) __PYX_ERR(9, 71, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 6)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + } + __pyx_v_constraints = values[0]; + __pyx_v_solution = values[1]; + __pyx_v_checkintegrality = values[2]; + __pyx_v_checklprows = values[3]; + __pyx_v_printreason = values[4]; + __pyx_v_completely = values[5]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("conscheck", 1, 6, 6, __pyx_nargs); __PYX_ERR(9, 71, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conscheck", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_30conscheck(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints, __pyx_v_solution, __pyx_v_checkintegrality, __pyx_v_checklprows, __pyx_v_printreason, __pyx_v_completely); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_30conscheck(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_solution, CYTHON_UNUSED PyObject *__pyx_v_checkintegrality, CYTHON_UNUSED PyObject *__pyx_v_checklprows, CYTHON_UNUSED PyObject *__pyx_v_printreason, CYTHON_UNUSED PyObject *__pyx_v_completely) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("conscheck", 1); + + /* "src/pyscipopt/conshdlr.pxi":73 + * def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely): + * '''calls feasibility check method of constraint handler ''' + * print("python error in conscheck: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":74 + * '''calls feasibility check method of constraint handler ''' + * print("python error in conscheck: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":71 + * return {} + * + * def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely): # <<<<<<<<<<<<<< + * '''calls feasibility check method of constraint handler ''' + * print("python error in conscheck: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conscheck", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":76 + * return {} + * + * def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming): # <<<<<<<<<<<<<< + * '''calls propagation method of constraint handler ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_33consprop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_32consprop, "Conshdlr.consprop(self, constraints, nusefulconss, nmarkedconss, proptiming)\ncalls propagation method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_33consprop = {"consprop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_33consprop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_32consprop}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_33consprop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_nusefulconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_nmarkedconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_proptiming = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consprop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,&__pyx_n_s_nusefulconss,&__pyx_n_s_nmarkedconss,&__pyx_n_s_proptiming,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 76, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nusefulconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 76, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consprop", 1, 4, 4, 1); __PYX_ERR(9, 76, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nmarkedconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 76, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consprop", 1, 4, 4, 2); __PYX_ERR(9, 76, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_proptiming)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 76, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("consprop", 1, 4, 4, 3); __PYX_ERR(9, 76, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consprop") < 0)) __PYX_ERR(9, 76, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + } + __pyx_v_constraints = values[0]; + __pyx_v_nusefulconss = values[1]; + __pyx_v_nmarkedconss = values[2]; + __pyx_v_proptiming = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consprop", 1, 4, 4, __pyx_nargs); __PYX_ERR(9, 76, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consprop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_32consprop(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints, __pyx_v_nusefulconss, __pyx_v_nmarkedconss, __pyx_v_proptiming); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_32consprop(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nusefulconss, CYTHON_UNUSED PyObject *__pyx_v_nmarkedconss, CYTHON_UNUSED PyObject *__pyx_v_proptiming) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("consprop", 1); + + /* "src/pyscipopt/conshdlr.pxi":78 + * def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming): + * '''calls propagation method of constraint handler ''' + * return {} # <<<<<<<<<<<<<< + * + * def conspresol(self, constraints, nrounds, presoltiming, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":76 + * return {} + * + * def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming): # <<<<<<<<<<<<<< + * '''calls propagation method of constraint handler ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consprop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":80 + * return {} + * + * def conspresol(self, constraints, nrounds, presoltiming, # <<<<<<<<<<<<<< + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_35conspresol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_34conspresol, "Conshdlr.conspresol(self, constraints, nrounds, presoltiming, nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict)\ncalls presolving method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_35conspresol = {"conspresol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_35conspresol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_34conspresol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_35conspresol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + CYTHON_UNUSED PyObject *__pyx_v_nrounds = 0; + CYTHON_UNUSED PyObject *__pyx_v_presoltiming = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewfixedvars = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewaggrvars = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewchgvartypes = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewchgbds = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewholes = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewdelconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewaddconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewupgdconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewchgcoefs = 0; + CYTHON_UNUSED PyObject *__pyx_v_nnewchgsides = 0; + PyObject *__pyx_v_result_dict = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[14] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("conspresol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,&__pyx_n_s_nrounds,&__pyx_n_s_presoltiming,&__pyx_n_s_nnewfixedvars,&__pyx_n_s_nnewaggrvars,&__pyx_n_s_nnewchgvartypes,&__pyx_n_s_nnewchgbds,&__pyx_n_s_nnewholes,&__pyx_n_s_nnewdelconss,&__pyx_n_s_nnewaddconss,&__pyx_n_s_nnewupgdconss,&__pyx_n_s_nnewchgcoefs,&__pyx_n_s_nnewchgsides,&__pyx_n_s_result_dict,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 14: values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nrounds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 1); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_presoltiming)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 2); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewfixedvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 3); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewaggrvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 4); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewchgvartypes)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[5]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 5); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewchgbds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[6]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 6); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (likely((values[7] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewholes)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[7]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 7); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (likely((values[8] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewdelconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[8]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 8); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (likely((values[9] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewaddconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[9]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 9); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (likely((values[10] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewupgdconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[10]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 10); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (likely((values[11] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewchgcoefs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[11]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 11); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 12: + if (likely((values[12] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nnewchgsides)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[12]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 12); __PYX_ERR(9, 80, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 13: + if (likely((values[13] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_result_dict)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[13]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 80, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, 13); __PYX_ERR(9, 80, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "conspresol") < 0)) __PYX_ERR(9, 80, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 14)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); + } + __pyx_v_constraints = values[0]; + __pyx_v_nrounds = values[1]; + __pyx_v_presoltiming = values[2]; + __pyx_v_nnewfixedvars = values[3]; + __pyx_v_nnewaggrvars = values[4]; + __pyx_v_nnewchgvartypes = values[5]; + __pyx_v_nnewchgbds = values[6]; + __pyx_v_nnewholes = values[7]; + __pyx_v_nnewdelconss = values[8]; + __pyx_v_nnewaddconss = values[9]; + __pyx_v_nnewupgdconss = values[10]; + __pyx_v_nnewchgcoefs = values[11]; + __pyx_v_nnewchgsides = values[12]; + __pyx_v_result_dict = values[13]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("conspresol", 1, 14, 14, __pyx_nargs); __PYX_ERR(9, 80, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conspresol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_34conspresol(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints, __pyx_v_nrounds, __pyx_v_presoltiming, __pyx_v_nnewfixedvars, __pyx_v_nnewaggrvars, __pyx_v_nnewchgvartypes, __pyx_v_nnewchgbds, __pyx_v_nnewholes, __pyx_v_nnewdelconss, __pyx_v_nnewaddconss, __pyx_v_nnewupgdconss, __pyx_v_nnewchgcoefs, __pyx_v_nnewchgsides, __pyx_v_result_dict); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_34conspresol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints, CYTHON_UNUSED PyObject *__pyx_v_nrounds, CYTHON_UNUSED PyObject *__pyx_v_presoltiming, CYTHON_UNUSED PyObject *__pyx_v_nnewfixedvars, CYTHON_UNUSED PyObject *__pyx_v_nnewaggrvars, CYTHON_UNUSED PyObject *__pyx_v_nnewchgvartypes, CYTHON_UNUSED PyObject *__pyx_v_nnewchgbds, CYTHON_UNUSED PyObject *__pyx_v_nnewholes, CYTHON_UNUSED PyObject *__pyx_v_nnewdelconss, CYTHON_UNUSED PyObject *__pyx_v_nnewaddconss, CYTHON_UNUSED PyObject *__pyx_v_nnewupgdconss, CYTHON_UNUSED PyObject *__pyx_v_nnewchgcoefs, CYTHON_UNUSED PyObject *__pyx_v_nnewchgsides, PyObject *__pyx_v_result_dict) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("conspresol", 1); + + /* "src/pyscipopt/conshdlr.pxi":84 + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict): + * '''calls presolving method of constraint handler ''' + * return result_dict # <<<<<<<<<<<<<< + * + * def consresprop(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result_dict); + __pyx_r = __pyx_v_result_dict; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":80 + * return {} + * + * def conspresol(self, constraints, nrounds, presoltiming, # <<<<<<<<<<<<<< + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict): + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":86 + * return result_dict + * + * def consresprop(self): # <<<<<<<<<<<<<< + * '''sets propagation conflict resolving method of constraint handler ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_37consresprop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_36consresprop, "Conshdlr.consresprop(self)\nsets propagation conflict resolving method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_37consresprop = {"consresprop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_37consresprop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_36consresprop}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_37consresprop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consresprop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("consresprop", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "consresprop", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_36consresprop(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_36consresprop(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("consresprop", 1); + + /* "src/pyscipopt/conshdlr.pxi":88 + * def consresprop(self): + * '''sets propagation conflict resolving method of constraint handler ''' + * return {} # <<<<<<<<<<<<<< + * + * def conslock(self, constraint, locktype, nlockspos, nlocksneg): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":86 + * return result_dict + * + * def consresprop(self): # <<<<<<<<<<<<<< + * '''sets propagation conflict resolving method of constraint handler ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consresprop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":90 + * return {} + * + * def conslock(self, constraint, locktype, nlockspos, nlocksneg): # <<<<<<<<<<<<<< + * '''variable rounding lock method of constraint handler''' + * print("python error in conslock: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_39conslock(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_38conslock, "Conshdlr.conslock(self, constraint, locktype, nlockspos, nlocksneg)\nvariable rounding lock method of constraint handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_39conslock = {"conslock", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_39conslock, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_38conslock}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_39conslock(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + CYTHON_UNUSED PyObject *__pyx_v_locktype = 0; + CYTHON_UNUSED PyObject *__pyx_v_nlockspos = 0; + CYTHON_UNUSED PyObject *__pyx_v_nlocksneg = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("conslock (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,&__pyx_n_s_locktype,&__pyx_n_s_nlockspos,&__pyx_n_s_nlocksneg,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 90, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_locktype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 90, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conslock", 1, 4, 4, 1); __PYX_ERR(9, 90, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nlockspos)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 90, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conslock", 1, 4, 4, 2); __PYX_ERR(9, 90, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nlocksneg)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 90, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("conslock", 1, 4, 4, 3); __PYX_ERR(9, 90, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "conslock") < 0)) __PYX_ERR(9, 90, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + } + __pyx_v_constraint = values[0]; + __pyx_v_locktype = values[1]; + __pyx_v_nlockspos = values[2]; + __pyx_v_nlocksneg = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("conslock", 1, 4, 4, __pyx_nargs); __PYX_ERR(9, 90, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conslock", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_38conslock(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint, __pyx_v_locktype, __pyx_v_nlockspos, __pyx_v_nlocksneg); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_38conslock(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint, CYTHON_UNUSED PyObject *__pyx_v_locktype, CYTHON_UNUSED PyObject *__pyx_v_nlockspos, CYTHON_UNUSED PyObject *__pyx_v_nlocksneg) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("conslock", 1); + + /* "src/pyscipopt/conshdlr.pxi":92 + * def conslock(self, constraint, locktype, nlockspos, nlocksneg): + * '''variable rounding lock method of constraint handler''' + * print("python error in conslock: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":93 + * '''variable rounding lock method of constraint handler''' + * print("python error in conslock: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * def consactive(self, constraint): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":90 + * return {} + * + * def conslock(self, constraint, locktype, nlockspos, nlocksneg): # <<<<<<<<<<<<<< + * '''variable rounding lock method of constraint handler''' + * print("python error in conslock: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.conslock", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":95 + * return {} + * + * def consactive(self, constraint): # <<<<<<<<<<<<<< + * '''sets activation notification method of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_41consactive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_40consactive, "Conshdlr.consactive(self, constraint)\nsets activation notification method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_41consactive = {"consactive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_41consactive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_40consactive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_41consactive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consactive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 95, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consactive") < 0)) __PYX_ERR(9, 95, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consactive", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 95, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consactive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_40consactive(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_40consactive(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consactive", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":99 + * pass + * + * def consdeactive(self, constraint): # <<<<<<<<<<<<<< + * '''sets deactivation notification method of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_43consdeactive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_42consdeactive, "Conshdlr.consdeactive(self, constraint)\nsets deactivation notification method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_43consdeactive = {"consdeactive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_43consdeactive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_42consdeactive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_43consdeactive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consdeactive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 99, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consdeactive") < 0)) __PYX_ERR(9, 99, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consdeactive", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 99, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consdeactive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_42consdeactive(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_42consdeactive(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consdeactive", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":103 + * pass + * + * def consenable(self, constraint): # <<<<<<<<<<<<<< + * '''sets enabling notification method of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_45consenable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_44consenable, "Conshdlr.consenable(self, constraint)\nsets enabling notification method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_45consenable = {"consenable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_45consenable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_44consenable}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_45consenable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consenable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 103, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consenable") < 0)) __PYX_ERR(9, 103, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consenable", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 103, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consenable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_44consenable(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_44consenable(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consenable", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":107 + * pass + * + * def consdisable(self, constraint): # <<<<<<<<<<<<<< + * '''sets disabling notification method of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_47consdisable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_46consdisable, "Conshdlr.consdisable(self, constraint)\nsets disabling notification method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_47consdisable = {"consdisable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_47consdisable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_46consdisable}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_47consdisable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consdisable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 107, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consdisable") < 0)) __PYX_ERR(9, 107, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consdisable", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 107, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consdisable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_46consdisable(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_46consdisable(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consdisable", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":111 + * pass + * + * def consdelvars(self, constraints): # <<<<<<<<<<<<<< + * '''calls variable deletion method of constraint handler''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_49consdelvars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_48consdelvars, "Conshdlr.consdelvars(self, constraints)\ncalls variable deletion method of constraint handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_49consdelvars = {"consdelvars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_49consdelvars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_48consdelvars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_49consdelvars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraints = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consdelvars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraints,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraints)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 111, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consdelvars") < 0)) __PYX_ERR(9, 111, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraints = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consdelvars", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 111, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consdelvars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_48consdelvars(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraints); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_48consdelvars(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraints) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consdelvars", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":115 + * pass + * + * def consprint(self, constraint): # <<<<<<<<<<<<<< + * '''sets constraint display method of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_51consprint(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_50consprint, "Conshdlr.consprint(self, constraint)\nsets constraint display method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_51consprint = {"consprint", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_51consprint, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_50consprint}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_51consprint(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consprint (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 115, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consprint") < 0)) __PYX_ERR(9, 115, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consprint", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 115, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consprint", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_50consprint(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_50consprint(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consprint", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":119 + * pass + * + * def conscopy(self): # <<<<<<<<<<<<<< + * '''sets copy method of both the constraint handler and each associated constraint''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_53conscopy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_52conscopy, "Conshdlr.conscopy(self)\nsets copy method of both the constraint handler and each associated constraint"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_53conscopy = {"conscopy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_53conscopy, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_52conscopy}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_53conscopy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("conscopy (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("conscopy", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "conscopy", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_52conscopy(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_52conscopy(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("conscopy", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":123 + * pass + * + * def consparse(self): # <<<<<<<<<<<<<< + * '''sets constraint parsing method of constraint handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_55consparse(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_54consparse, "Conshdlr.consparse(self)\nsets constraint parsing method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_55consparse = {"consparse", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_55consparse, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_54consparse}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_55consparse(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consparse (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("consparse", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "consparse", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_54consparse(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_54consparse(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consparse", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":127 + * pass + * + * def consgetvars(self, constraint): # <<<<<<<<<<<<<< + * '''sets constraint variable getter method of constraint handler''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_57consgetvars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_56consgetvars, "Conshdlr.consgetvars(self, constraint)\nsets constraint variable getter method of constraint handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_57consgetvars = {"consgetvars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_57consgetvars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_56consgetvars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_57consgetvars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetvars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 127, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consgetvars") < 0)) __PYX_ERR(9, 127, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consgetvars", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 127, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consgetvars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_56consgetvars(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_56consgetvars(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetvars", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":131 + * pass + * + * def consgetnvars(self, constraint): # <<<<<<<<<<<<<< + * '''sets constraint variable number getter method of constraint handler ''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_59consgetnvars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_58consgetnvars, "Conshdlr.consgetnvars(self, constraint)\nsets constraint variable number getter method of constraint handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_59consgetnvars = {"consgetnvars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_59consgetnvars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_58consgetnvars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_59consgetnvars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetnvars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(9, 131, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "consgetnvars") < 0)) __PYX_ERR(9, 131, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("consgetnvars", 1, 1, 1, __pyx_nargs); __PYX_ERR(9, 131, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consgetnvars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_58consgetnvars(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_58consgetnvars(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("consgetnvars", 1); + + /* "src/pyscipopt/conshdlr.pxi":133 + * def consgetnvars(self, constraint): + * '''sets constraint variable number getter method of constraint handler ''' + * return {} # <<<<<<<<<<<<<< + * + * def consgetdivebdchgs(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":131 + * pass + * + * def consgetnvars(self, constraint): # <<<<<<<<<<<<<< + * '''sets constraint variable number getter method of constraint handler ''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.consgetnvars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":135 + * return {} + * + * def consgetdivebdchgs(self): # <<<<<<<<<<<<<< + * '''calls diving solution enforcement callback of constraint handler, if it exists ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_61consgetdivebdchgs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_60consgetdivebdchgs, "Conshdlr.consgetdivebdchgs(self)\ncalls diving solution enforcement callback of constraint handler, if it exists "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_61consgetdivebdchgs = {"consgetdivebdchgs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_61consgetdivebdchgs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_60consgetdivebdchgs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_61consgetdivebdchgs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetdivebdchgs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("consgetdivebdchgs", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "consgetdivebdchgs", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_60consgetdivebdchgs(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_60consgetdivebdchgs(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetdivebdchgs", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":139 + * pass + * + * def consgetpermsymgraph(self): # <<<<<<<<<<<<<< + * '''permutation symmetry detection graph getter callback, if it exists ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_63consgetpermsymgraph(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_62consgetpermsymgraph, "Conshdlr.consgetpermsymgraph(self)\npermutation symmetry detection graph getter callback, if it exists "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_63consgetpermsymgraph = {"consgetpermsymgraph", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_63consgetpermsymgraph, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_62consgetpermsymgraph}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_63consgetpermsymgraph(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetpermsymgraph (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("consgetpermsymgraph", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "consgetpermsymgraph", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_62consgetpermsymgraph(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_62consgetpermsymgraph(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetpermsymgraph", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":143 + * pass + * + * def consgetsignedpermsymgraph(self): # <<<<<<<<<<<<<< + * '''signed permutation symmetry detection graph getter callback, if it exists ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_65consgetsignedpermsymgraph(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_64consgetsignedpermsymgraph, "Conshdlr.consgetsignedpermsymgraph(self)\nsigned permutation symmetry detection graph getter callback, if it exists "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_65consgetsignedpermsymgraph = {"consgetsignedpermsymgraph", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_65consgetsignedpermsymgraph, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_64consgetsignedpermsymgraph}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_65consgetsignedpermsymgraph(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetsignedpermsymgraph (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("consgetsignedpermsymgraph", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "consgetsignedpermsymgraph", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_64consgetsignedpermsymgraph(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_64consgetsignedpermsymgraph(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("consgetsignedpermsymgraph", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":5 + * + * cdef class Conshdlr: + * cdef public Model model # <<<<<<<<<<<<<< + * cdef public str name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Conshdlr_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(9, 5, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Conshdlr_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":6 + * cdef class Conshdlr: + * cdef public Model model + * cdef public str name # <<<<<<<<<<<<<< + * + * def consfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_4name_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Conshdlr_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(PyUnicode_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_value))) __PYX_ERR(9, 6, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_4name_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Conshdlr_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_67__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_66__reduce_cython__, "Conshdlr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_67__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_67__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_66__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_67__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_66__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_66__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model, self.name) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->name)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None or self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None or self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, None), state + */ + /*else*/ { + __pyx_t_4 = (((PyObject *)__pyx_v_self->model) != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->name != ((PyObject*)Py_None)); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Conshdlr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, None), state + * else: + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Conshdlr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Conshdlr); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Conshdlr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_69__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Conshdlr_68__setstate_cython__, "Conshdlr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Conshdlr_69__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_69__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_68__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Conshdlr_69__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Conshdlr_68__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Conshdlr_68__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Conshdlr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Conshdlr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Conshdlr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Conshdlr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":149 + * + * # local helper functions for the interface + * cdef Conshdlr getPyConshdlr(SCIP_CONSHDLR* conshdlr): # <<<<<<<<<<<<<< + * cdef SCIP_CONSHDLRDATA* conshdlrdata + * conshdlrdata = SCIPconshdlrGetData(conshdlr) + */ + +static struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_f_9pyscipopt_4scip_getPyConshdlr(SCIP_CONSHDLR *__pyx_v_conshdlr) { + SCIP_CONSHDLRDATA *__pyx_v_conshdlrdata; + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPyConshdlr", 1); + + /* "src/pyscipopt/conshdlr.pxi":151 + * cdef Conshdlr getPyConshdlr(SCIP_CONSHDLR* conshdlr): + * cdef SCIP_CONSHDLRDATA* conshdlrdata + * conshdlrdata = SCIPconshdlrGetData(conshdlr) # <<<<<<<<<<<<<< + * return conshdlrdata + * + */ + __pyx_v_conshdlrdata = SCIPconshdlrGetData(__pyx_v_conshdlr); + + /* "src/pyscipopt/conshdlr.pxi":152 + * cdef SCIP_CONSHDLRDATA* conshdlrdata + * conshdlrdata = SCIPconshdlrGetData(conshdlr) + * return conshdlrdata # <<<<<<<<<<<<<< + * + * cdef Constraint getPyCons(SCIP_CONS* cons): + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_conshdlrdata)); + __pyx_r = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v_conshdlrdata); + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":149 + * + * # local helper functions for the interface + * cdef Conshdlr getPyConshdlr(SCIP_CONSHDLR* conshdlr): # <<<<<<<<<<<<<< + * cdef SCIP_CONSHDLRDATA* conshdlrdata + * conshdlrdata = SCIPconshdlrGetData(conshdlr) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":154 + * return conshdlrdata + * + * cdef Constraint getPyCons(SCIP_CONS* cons): # <<<<<<<<<<<<<< + * cdef SCIP_CONSDATA* consdata + * consdata = SCIPconsGetData(cons) + */ + +static struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_f_9pyscipopt_4scip_getPyCons(SCIP_CONS *__pyx_v_cons) { + SCIP_CONSDATA *__pyx_v_consdata; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPyCons", 1); + + /* "src/pyscipopt/conshdlr.pxi":156 + * cdef Constraint getPyCons(SCIP_CONS* cons): + * cdef SCIP_CONSDATA* consdata + * consdata = SCIPconsGetData(cons) # <<<<<<<<<<<<<< + * return consdata + * + */ + __pyx_v_consdata = SCIPconsGetData(__pyx_v_cons); + + /* "src/pyscipopt/conshdlr.pxi":157 + * cdef SCIP_CONSDATA* consdata + * consdata = SCIPconsGetData(cons) + * return consdata # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_consdata)); + __pyx_r = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_consdata); + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":154 + * return conshdlrdata + * + * cdef Constraint getPyCons(SCIP_CONS* cons): # <<<<<<<<<<<<<< + * cdef SCIP_CONSDATA* consdata + * consdata = SCIPconsGetData(cons) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":161 + * + * + * cdef SCIP_RETCODE PyConshdlrCopy (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConshdlrCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_CONSHDLR *__pyx_v_conshdlr, CYTHON_UNUSED SCIP_Bool *__pyx_v_valid) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/conshdlr.pxi":162 + * + * cdef SCIP_RETCODE PyConshdlrCopy (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":161 + * + * + * cdef SCIP_RETCODE PyConshdlrCopy (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":164 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consfree() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsFree", 0); + + /* "src/pyscipopt/conshdlr.pxi":165 + * + * cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyConshdlr.consfree() + * Py_DECREF(PyConshdlr) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":166 + * cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyConshdlr) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":167 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consfree() + * Py_DECREF(PyConshdlr) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyConshdlr)); + + /* "src/pyscipopt/conshdlr.pxi":168 + * PyConshdlr.consfree() + * Py_DECREF(PyConshdlr) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":164 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consfree() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":170 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsInit", 0); + + /* "src/pyscipopt/conshdlr.pxi":171 + * + * cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":172 + * cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":173 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinit(constraints) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":174 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * PyConshdlr.consinit(constraints) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 174, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":175 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinit(constraints) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consinit); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_constraints}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":176 + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinit(constraints) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":170 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":178 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsExit", 0); + + /* "src/pyscipopt/conshdlr.pxi":179 + * + * cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":180 + * cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":181 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexit(constraints) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":182 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * PyConshdlr.consexit(constraints) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 182, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":183 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexit(constraints) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consexit); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_constraints}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":184 + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexit(constraints) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":178 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":186 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsInitpre(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsInitpre", 0); + + /* "src/pyscipopt/conshdlr.pxi":187 + * + * cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":188 + * cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":189 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinitpre(constraints) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":190 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * PyConshdlr.consinitpre(constraints) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 190, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":191 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinitpre(constraints) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consinitpre); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_constraints}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":192 + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinitpre(constraints) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":186 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsInitpre", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":194 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsExitpre(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsExitpre", 0); + + /* "src/pyscipopt/conshdlr.pxi":195 + * + * cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 195, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":196 + * cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":197 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexitpre(constraints) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":198 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * PyConshdlr.consexitpre(constraints) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 198, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":199 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexitpre(constraints) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consexitpre); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_constraints}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":200 + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexitpre(constraints) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":194 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsExitpre", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":202 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsInitsol", 0); + + /* "src/pyscipopt/conshdlr.pxi":203 + * + * cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":204 + * cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":205 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinitsol(constraints) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":206 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * PyConshdlr.consinitsol(constraints) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 206, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":207 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinitsol(constraints) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consinitsol); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_constraints}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":208 + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consinitsol(constraints) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":202 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":210 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, SCIP_Bool __pyx_v_restart) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsExitsol", 0); + + /* "src/pyscipopt/conshdlr.pxi":211 + * + * cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":212 + * cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":213 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexitsol(constraints, restart) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":214 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * PyConshdlr.consexitsol(constraints, restart) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 214, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":215 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexitsol(constraints, restart) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consexitsol); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_restart); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_constraints, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":216 + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consexitsol(constraints, restart) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsDelete (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":210 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":218 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsDelete (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsDelete(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons, SCIP_CONSDATA **__pyx_v_consdata) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsDelete", 0); + + /* "src/pyscipopt/conshdlr.pxi":219 + * + * cdef SCIP_RETCODE PyConsDelete (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyCons = getPyCons(cons) + * assert consdata[0] == PyCons + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":220 + * cdef SCIP_RETCODE PyConsDelete (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * assert consdata[0] == PyCons + * PyConshdlr.consdelete(PyCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":221 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + * assert consdata[0] == PyCons # <<<<<<<<<<<<<< + * PyConshdlr.consdelete(PyCons) + * consdata[0] = NULL + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = PyObject_RichCompare(((PyObject *)(__pyx_v_consdata[0])), ((PyObject *)__pyx_v_PyCons), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 221, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(9, 221, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(9, 221, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(9, 221, __pyx_L1_error) + #endif + + /* "src/pyscipopt/conshdlr.pxi":222 + * PyCons = getPyCons(cons) + * assert consdata[0] == PyCons + * PyConshdlr.consdelete(PyCons) # <<<<<<<<<<<<<< + * consdata[0] = NULL + * Py_DECREF(PyCons) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consdelete); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_PyCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":223 + * assert consdata[0] == PyCons + * PyConshdlr.consdelete(PyCons) + * consdata[0] = NULL # <<<<<<<<<<<<<< + * Py_DECREF(PyCons) + * return SCIP_OKAY + */ + (__pyx_v_consdata[0]) = NULL; + + /* "src/pyscipopt/conshdlr.pxi":224 + * PyConshdlr.consdelete(PyCons) + * consdata[0] = NULL + * Py_DECREF(PyCons) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyCons)); + + /* "src/pyscipopt/conshdlr.pxi":225 + * consdata[0] = NULL + * Py_DECREF(PyCons) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":218 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsDelete (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsDelete", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":227 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons) noexcept with gil: # <<<<<<<<<<<<<< + * cdef Constraint PyTargetCons + * PyConshdlr = getPyConshdlr(conshdlr) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsTrans(SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_sourcecons, SCIP_CONS **__pyx_v_targetcons) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyTargetCons = 0; + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PySourceCons = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + SCIP_CONS *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + char const *__pyx_t_10; + SCIP_Bool __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + SCIP_Bool __pyx_t_17; + SCIP_Bool __pyx_t_18; + SCIP_Bool __pyx_t_19; + SCIP_Bool __pyx_t_20; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsTrans", 0); + + /* "src/pyscipopt/conshdlr.pxi":229 + * cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons) noexcept with gil: + * cdef Constraint PyTargetCons + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PySourceCons = getPyCons(sourcecons) + * result_dict = PyConshdlr.constrans(PySourceCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":230 + * cdef Constraint PyTargetCons + * PyConshdlr = getPyConshdlr(conshdlr) + * PySourceCons = getPyCons(sourcecons) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.constrans(PySourceCons) + * + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_sourcecons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PySourceCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":231 + * PyConshdlr = getPyConshdlr(conshdlr) + * PySourceCons = getPyCons(sourcecons) + * result_dict = PyConshdlr.constrans(PySourceCons) # <<<<<<<<<<<<<< + * + * # create target (transform) constraint: if user doesn't return a constraint, copy PySourceCons + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_constrans); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PySourceCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":235 + * # create target (transform) constraint: if user doesn't return a constraint, copy PySourceCons + * # otherwise use the created cons + * if "targetcons" in result_dict: # <<<<<<<<<<<<<< + * PyTargetCons = result_dict.get("targetcons") + * targetcons[0] = PyTargetCons.scip_cons + */ + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_targetcons, __pyx_v_result_dict, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(9, 235, __pyx_L1_error) + if (__pyx_t_5) { + + /* "src/pyscipopt/conshdlr.pxi":236 + * # otherwise use the created cons + * if "targetcons" in result_dict: + * PyTargetCons = result_dict.get("targetcons") # <<<<<<<<<<<<<< + * targetcons[0] = PyTargetCons.scip_cons + * Py_INCREF(PyTargetCons) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_n_u_targetcons}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Constraint))))) __PYX_ERR(9, 236, __pyx_L1_error) + __pyx_v_PyTargetCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":237 + * if "targetcons" in result_dict: + * PyTargetCons = result_dict.get("targetcons") + * targetcons[0] = PyTargetCons.scip_cons # <<<<<<<<<<<<<< + * Py_INCREF(PyTargetCons) + * else: + */ + __pyx_t_6 = __pyx_v_PyTargetCons->scip_cons; + (__pyx_v_targetcons[0]) = __pyx_t_6; + + /* "src/pyscipopt/conshdlr.pxi":238 + * PyTargetCons = result_dict.get("targetcons") + * targetcons[0] = PyTargetCons.scip_cons + * Py_INCREF(PyTargetCons) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPcreateCons(scip, targetcons, str_conversion(PySourceCons.name), conshdlr, PySourceCons, + */ + Py_INCREF(((PyObject *)__pyx_v_PyTargetCons)); + + /* "src/pyscipopt/conshdlr.pxi":235 + * # create target (transform) constraint: if user doesn't return a constraint, copy PySourceCons + * # otherwise use the created cons + * if "targetcons" in result_dict: # <<<<<<<<<<<<<< + * PyTargetCons = result_dict.get("targetcons") + * targetcons[0] = PyTargetCons.scip_cons + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/conshdlr.pxi":240 + * Py_INCREF(PyTargetCons) + * else: + * PY_SCIP_CALL(SCIPcreateCons(scip, targetcons, str_conversion(PySourceCons.name), conshdlr, PySourceCons, # <<<<<<<<<<<<<< + * PySourceCons.isInitial(), PySourceCons.isSeparated(), PySourceCons.isEnforced(), PySourceCons.isChecked(), + * PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(), + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_t_3); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(9, 240, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":241 + * else: + * PY_SCIP_CALL(SCIPcreateCons(scip, targetcons, str_conversion(PySourceCons.name), conshdlr, PySourceCons, + * PySourceCons.isInitial(), PySourceCons.isSeparated(), PySourceCons.isEnforced(), PySourceCons.isChecked(), # <<<<<<<<<<<<<< + * PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(), + * PySourceCons.isRemovable(), PySourceCons.isStickingAtNode())) + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isInitial); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isSeparated); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isEnforced); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isChecked); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/conshdlr.pxi":242 + * PY_SCIP_CALL(SCIPcreateCons(scip, targetcons, str_conversion(PySourceCons.name), conshdlr, PySourceCons, + * PySourceCons.isInitial(), PySourceCons.isSeparated(), PySourceCons.isEnforced(), PySourceCons.isChecked(), + * PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(), # <<<<<<<<<<<<<< + * PySourceCons.isRemovable(), PySourceCons.isStickingAtNode())) + * return SCIP_OKAY + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isPropagated); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isLocal); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isModifiable); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_17 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isDynamic); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_18 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 242, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/conshdlr.pxi":243 + * PySourceCons.isInitial(), PySourceCons.isSeparated(), PySourceCons.isEnforced(), PySourceCons.isChecked(), + * PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(), + * PySourceCons.isRemovable(), PySourceCons.isStickingAtNode())) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isRemovable); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_19 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 243, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySourceCons), __pyx_n_s_isStickingAtNode); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 243, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/conshdlr.pxi":240 + * Py_INCREF(PyTargetCons) + * else: + * PY_SCIP_CALL(SCIPcreateCons(scip, targetcons, str_conversion(PySourceCons.name), conshdlr, PySourceCons, # <<<<<<<<<<<<<< + * PySourceCons.isInitial(), PySourceCons.isSeparated(), PySourceCons.isEnforced(), PySourceCons.isChecked(), + * PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(), + */ + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateCons(__pyx_v_scip, __pyx_v_targetcons, __pyx_t_10, __pyx_v_conshdlr, ((SCIP_CONSDATA *)__pyx_v_PySourceCons), __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20)); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/conshdlr.pxi":244 + * PySourceCons.isPropagated(), PySourceCons.isLocal(), PySourceCons.isModifiable(), PySourceCons.isDynamic(), + * PySourceCons.isRemovable(), PySourceCons.isStickingAtNode())) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":227 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons) noexcept with gil: # <<<<<<<<<<<<<< + * cdef Constraint PyTargetCons + * PyConshdlr = getPyConshdlr(conshdlr) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsTrans", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyTargetCons); + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PySourceCons); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":246 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsInitlp(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, SCIP_Bool *__pyx_v_infeasible) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + SCIP_Bool __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsInitlp", 0); + + /* "src/pyscipopt/conshdlr.pxi":247 + * + * cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":248 + * cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":249 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consinitlp(constraints) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":250 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.consinitlp(constraints) + * infeasible[0] = result_dict.get("infeasible", infeasible[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 250, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":251 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consinitlp(constraints) # <<<<<<<<<<<<<< + * infeasible[0] = result_dict.get("infeasible", infeasible[0]) + * return SCIP_OKAY + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consinitlp); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_constraints}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":252 + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consinitlp(constraints) + * infeasible[0] = result_dict.get("infeasible", infeasible[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyBool_FromLong((__pyx_v_infeasible[0])); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_n_u_infeasible, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_9 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 252, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_infeasible[0]) = __pyx_t_9; + + /* "src/pyscipopt/conshdlr.pxi":253 + * result_dict = PyConshdlr.consinitlp(constraints) + * infeasible[0] = result_dict.get("infeasible", infeasible[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":246 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsInitlp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":255 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsSepalp(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, int __pyx_v_nusefulconss, SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + SCIP_RESULT __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsSepalp", 0); + + /* "src/pyscipopt/conshdlr.pxi":256 + * + * cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":257 + * cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":258 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.conssepalp(constraints, nusefulconss) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":259 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.conssepalp(constraints, nusefulconss) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 259, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":260 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.conssepalp(constraints, nusefulconss) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_conssepalp); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nusefulconss); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_constraints, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":261 + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.conssepalp(constraints, nusefulconss) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_n_u_result, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_9 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_9 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(9, 261, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_9; + + /* "src/pyscipopt/conshdlr.pxi":262 + * result_dict = PyConshdlr.conssepalp(constraints, nusefulconss) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":255 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsSepalp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":264 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, # <<<<<<<<<<<<<< + * SCIP_SOL* sol, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsSepasol(SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, int __pyx_v_nusefulconss, SCIP_SOL *__pyx_v_sol, SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_solution = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + SCIP_RESULT __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsSepasol", 0); + + /* "src/pyscipopt/conshdlr.pxi":266 + * cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + * SCIP_SOL* sol, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":267 + * SCIP_SOL* sol, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":268 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":269 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.conssepasol(constraints, nusefulconss, solution) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 269, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":270 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.conssepasol(constraints, nusefulconss, solution) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":271 + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.conssepasol(constraints, nusefulconss, solution) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_conssepasol); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nusefulconss); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_v_constraints, __pyx_t_7, __pyx_v_solution}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 3+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":272 + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.conssepasol(constraints, nusefulconss, solution) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_n_u_result, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_9 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_9 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(9, 272, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_9; + + /* "src/pyscipopt/conshdlr.pxi":273 + * result_dict = PyConshdlr.conssepasol(constraints, nusefulconss, solution) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":264 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, # <<<<<<<<<<<<<< + * SCIP_SOL* sol, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsSepasol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":275 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, # <<<<<<<<<<<<<< + * SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsEnfolp(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, int __pyx_v_nusefulconss, SCIP_Bool __pyx_v_solinfeasible, SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + SCIP_RESULT __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsEnfolp", 0); + + /* "src/pyscipopt/conshdlr.pxi":277 + * cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + * SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":278 + * SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":279 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":280 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 280, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":281 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consenfolp); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nusefulconss); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_solinfeasible); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_9, __pyx_v_constraints, __pyx_t_7, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 3+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":282 + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_n_u_result, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_10 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_10 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(9, 282, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_10; + + /* "src/pyscipopt/conshdlr.pxi":283 + * result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * 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: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":275 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, # <<<<<<<<<<<<<< + * SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsEnfolp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":285 + * return SCIP_OKAY + * + * 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: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsEnforelax(SCIP *__pyx_v_scip, SCIP_SOL *__pyx_v_sol, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, int __pyx_v_nusefulconss, SCIP_Bool __pyx_v_solinfeasible, SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_solution = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + SCIP_RESULT __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsEnforelax", 0); + + /* "src/pyscipopt/conshdlr.pxi":286 + * + * 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: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":287 + * 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: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":288 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":289 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.consenforelax(solution, constraints, nusefulconss, solinfeasible) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 289, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":290 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.consenforelax(solution, constraints, nusefulconss, solinfeasible) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":291 + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.consenforelax(solution, constraints, nusefulconss, solinfeasible) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consenforelax); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nusefulconss); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_solinfeasible); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_9, __pyx_v_solution, __pyx_v_constraints, __pyx_t_7, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 4+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":292 + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.consenforelax(solution, constraints, nusefulconss, solinfeasible) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_n_u_result, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_10 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_10 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(9, 292, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_10; + + /* "src/pyscipopt/conshdlr.pxi":293 + * result_dict = PyConshdlr.consenforelax(solution, constraints, nusefulconss, solinfeasible) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":285 + * return SCIP_OKAY + * + * 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: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsEnforelax", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":295 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, # <<<<<<<<<<<<<< + * SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsEnfops(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, int __pyx_v_nusefulconss, SCIP_Bool __pyx_v_solinfeasible, SCIP_Bool __pyx_v_objinfeasible, SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + SCIP_RESULT __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsEnfops", 0); + + /* "src/pyscipopt/conshdlr.pxi":297 + * cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, + * SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":298 + * SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":299 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":300 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 300, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":301 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consenfops); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nusefulconss); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_solinfeasible); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_objinfeasible); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_10, __pyx_v_constraints, __pyx_t_7, __pyx_t_8, __pyx_t_9}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 4+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":302 + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_n_u_result, __pyx_t_9}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_11 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_11 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(9, 302, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_11; + + /* "src/pyscipopt/conshdlr.pxi":303 + * result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":295 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, # <<<<<<<<<<<<<< + * SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsEnfops", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":305 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality, # <<<<<<<<<<<<<< + * SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsCheck(SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, SCIP_SOL *__pyx_v_sol, SCIP_Bool __pyx_v_checkintegrality, SCIP_Bool __pyx_v_checklprows, SCIP_Bool __pyx_v_printreason, SCIP_Bool __pyx_v_completely, SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_solution = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + SCIP_RESULT __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsCheck", 0); + + /* "src/pyscipopt/conshdlr.pxi":307 + * cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality, + * SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":308 + * SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":309 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":310 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.conscheck(constraints, solution, checkintegrality, checklprows, printreason, completely) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 310, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":311 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.conscheck(constraints, solution, checkintegrality, checklprows, printreason, completely) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":312 + * constraints.append(getPyCons(conss[i])) + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.conscheck(constraints, solution, checkintegrality, checklprows, printreason, completely) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_conscheck); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_checkintegrality); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyBool_FromLong(__pyx_v_checklprows); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_printreason); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyBool_FromLong(__pyx_v_completely); if (unlikely(!__pyx_t_10)) __PYX_ERR(9, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[7] = {__pyx_t_11, __pyx_v_constraints, __pyx_v_solution, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 6+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":313 + * solution = Solution.create(scip, sol) + * result_dict = PyConshdlr.conscheck(constraints, solution, checkintegrality, checklprows, printreason, completely) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_10)) __PYX_ERR(9, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_9 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_n_u_result, __pyx_t_10}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_12 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_12 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(9, 313, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_12; + + /* "src/pyscipopt/conshdlr.pxi":314 + * result_dict = PyConshdlr.conscheck(constraints, solution, checkintegrality, checklprows, printreason, completely) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":305 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality, # <<<<<<<<<<<<<< + * SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsCheck", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":316 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss, # <<<<<<<<<<<<<< + * SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsProp(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, int __pyx_v_nusefulconss, int __pyx_v_nmarkedconss, SCIP_PROPTIMING __pyx_v_proptiming, SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + SCIP_RESULT __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsProp", 0); + + /* "src/pyscipopt/conshdlr.pxi":318 + * cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss, + * SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":319 + * SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":320 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":321 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 321, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":322 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consprop); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nusefulconss); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_nmarkedconss); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_SCIP_PROPTIMING(__pyx_v_proptiming); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_10, __pyx_v_constraints, __pyx_t_7, __pyx_t_8, __pyx_t_9}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 4+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":323 + * constraints.append(getPyCons(conss[i])) + * result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_n_u_result, __pyx_t_9}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_11 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_11 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(9, 323, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_11; + + /* "src/pyscipopt/conshdlr.pxi":324 + * result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":316 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss, # <<<<<<<<<<<<<< + * SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsProp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":326 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming, # <<<<<<<<<<<<<< + * int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + * int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsPresol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, int __pyx_v_nrounds, SCIP_PRESOLTIMING __pyx_v_presoltiming, int __pyx_v_nnewfixedvars, int __pyx_v_nnewaggrvars, int __pyx_v_nnewchgvartypes, int __pyx_v_nnewchgbds, int __pyx_v_nnewholes, int __pyx_v_nnewdelconss, int __pyx_v_nnewaddconss, int __pyx_v_nnewupgdconss, int __pyx_v_nnewchgcoefs, int __pyx_v_nnewchgsides, int *__pyx_v_nfixedvars, int *__pyx_v_naggrvars, int *__pyx_v_nchgvartypes, int *__pyx_v_nchgbds, int *__pyx_v_naddholes, int *__pyx_v_ndelconss, int *__pyx_v_naddconss, int *__pyx_v_nupgdconss, int *__pyx_v_nchgcoefs, int *__pyx_v_nchgsides, SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + SCIP_RESULT __pyx_t_20; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsPresol", 0); + + /* "src/pyscipopt/conshdlr.pxi":331 + * int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes, + * int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":332 + * int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":333 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * # dictionary for input/output parameters + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":334 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * # dictionary for input/output parameters + * result_dict = {} + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 334, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 334, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":336 + * constraints.append(getPyCons(conss[i])) + * # dictionary for input/output parameters + * result_dict = {} # <<<<<<<<<<<<<< + * result_dict["nfixedvars"] = nfixedvars[0] + * result_dict["naggrvars"] = naggrvars[0] + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result_dict = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":337 + * # dictionary for input/output parameters + * result_dict = {} + * result_dict["nfixedvars"] = nfixedvars[0] # <<<<<<<<<<<<<< + * result_dict["naggrvars"] = naggrvars[0] + * result_dict["nchgvartypes"] = nchgvartypes[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nfixedvars[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nfixedvars, __pyx_t_1) < 0))) __PYX_ERR(9, 337, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":338 + * result_dict = {} + * result_dict["nfixedvars"] = nfixedvars[0] + * result_dict["naggrvars"] = naggrvars[0] # <<<<<<<<<<<<<< + * result_dict["nchgvartypes"] = nchgvartypes[0] + * result_dict["nchgbds"] = nchgbds[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_naggrvars[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_naggrvars, __pyx_t_1) < 0))) __PYX_ERR(9, 338, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":339 + * result_dict["nfixedvars"] = nfixedvars[0] + * result_dict["naggrvars"] = naggrvars[0] + * result_dict["nchgvartypes"] = nchgvartypes[0] # <<<<<<<<<<<<<< + * result_dict["nchgbds"] = nchgbds[0] + * result_dict["naddholes"] = naddholes[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgvartypes[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nchgvartypes, __pyx_t_1) < 0))) __PYX_ERR(9, 339, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":340 + * result_dict["naggrvars"] = naggrvars[0] + * result_dict["nchgvartypes"] = nchgvartypes[0] + * result_dict["nchgbds"] = nchgbds[0] # <<<<<<<<<<<<<< + * result_dict["naddholes"] = naddholes[0] + * result_dict["ndelconss"] = ndelconss[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgbds[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nchgbds, __pyx_t_1) < 0))) __PYX_ERR(9, 340, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":341 + * result_dict["nchgvartypes"] = nchgvartypes[0] + * result_dict["nchgbds"] = nchgbds[0] + * result_dict["naddholes"] = naddholes[0] # <<<<<<<<<<<<<< + * result_dict["ndelconss"] = ndelconss[0] + * result_dict["naddconss"] = naddconss[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_naddholes[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_naddholes, __pyx_t_1) < 0))) __PYX_ERR(9, 341, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":342 + * result_dict["nchgbds"] = nchgbds[0] + * result_dict["naddholes"] = naddholes[0] + * result_dict["ndelconss"] = ndelconss[0] # <<<<<<<<<<<<<< + * result_dict["naddconss"] = naddconss[0] + * result_dict["nupgdconss"] = nupgdconss[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_ndelconss[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_ndelconss, __pyx_t_1) < 0))) __PYX_ERR(9, 342, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":343 + * result_dict["naddholes"] = naddholes[0] + * result_dict["ndelconss"] = ndelconss[0] + * result_dict["naddconss"] = naddconss[0] # <<<<<<<<<<<<<< + * result_dict["nupgdconss"] = nupgdconss[0] + * result_dict["nchgcoefs"] = nchgcoefs[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_naddconss[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_naddconss, __pyx_t_1) < 0))) __PYX_ERR(9, 343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":344 + * result_dict["ndelconss"] = ndelconss[0] + * result_dict["naddconss"] = naddconss[0] + * result_dict["nupgdconss"] = nupgdconss[0] # <<<<<<<<<<<<<< + * result_dict["nchgcoefs"] = nchgcoefs[0] + * result_dict["nchgsides"] = nchgsides[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nupgdconss[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nupgdconss, __pyx_t_1) < 0))) __PYX_ERR(9, 344, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":345 + * result_dict["naddconss"] = naddconss[0] + * result_dict["nupgdconss"] = nupgdconss[0] + * result_dict["nchgcoefs"] = nchgcoefs[0] # <<<<<<<<<<<<<< + * result_dict["nchgsides"] = nchgsides[0] + * result_dict["result"] = result[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgcoefs[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nchgcoefs, __pyx_t_1) < 0))) __PYX_ERR(9, 345, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":346 + * result_dict["nupgdconss"] = nupgdconss[0] + * result_dict["nchgcoefs"] = nchgcoefs[0] + * result_dict["nchgsides"] = nchgsides[0] # <<<<<<<<<<<<<< + * result_dict["result"] = result[0] + * PyConshdlr.conspresol(constraints, nrounds, presoltiming, + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgsides[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nchgsides, __pyx_t_1) < 0))) __PYX_ERR(9, 346, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":347 + * result_dict["nchgcoefs"] = nchgcoefs[0] + * result_dict["nchgsides"] = nchgsides[0] + * result_dict["result"] = result[0] # <<<<<<<<<<<<<< + * PyConshdlr.conspresol(constraints, nrounds, presoltiming, + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + */ + __pyx_t_1 = __Pyx_PyInt_From_SCIP_RESULT((__pyx_v_result[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_result, __pyx_t_1) < 0))) __PYX_ERR(9, 347, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":348 + * result_dict["nchgsides"] = nchgsides[0] + * result_dict["result"] = result[0] + * PyConshdlr.conspresol(constraints, nrounds, presoltiming, # <<<<<<<<<<<<<< + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_conspresol); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nrounds); if (unlikely(!__pyx_t_7)) __PYX_ERR(9, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(__pyx_v_presoltiming); if (unlikely(!__pyx_t_8)) __PYX_ERR(9, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "src/pyscipopt/conshdlr.pxi":349 + * result_dict["result"] = result[0] + * PyConshdlr.conspresol(constraints, nrounds, presoltiming, + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, # <<<<<<<<<<<<<< + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + * result[0] = result_dict["result"] + */ + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_nnewfixedvars); if (unlikely(!__pyx_t_9)) __PYX_ERR(9, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_nnewaggrvars); if (unlikely(!__pyx_t_10)) __PYX_ERR(9, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_nnewchgvartypes); if (unlikely(!__pyx_t_11)) __PYX_ERR(9, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_nnewchgbds); if (unlikely(!__pyx_t_12)) __PYX_ERR(9, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_nnewholes); if (unlikely(!__pyx_t_13)) __PYX_ERR(9, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + + /* "src/pyscipopt/conshdlr.pxi":350 + * PyConshdlr.conspresol(constraints, nrounds, presoltiming, + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) # <<<<<<<<<<<<<< + * result[0] = result_dict["result"] + * nfixedvars[0] = result_dict["nfixedvars"] + */ + __pyx_t_14 = __Pyx_PyInt_From_int(__pyx_v_nnewdelconss); if (unlikely(!__pyx_t_14)) __PYX_ERR(9, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_nnewaddconss); if (unlikely(!__pyx_t_15)) __PYX_ERR(9, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_16 = __Pyx_PyInt_From_int(__pyx_v_nnewupgdconss); if (unlikely(!__pyx_t_16)) __PYX_ERR(9, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_17 = __Pyx_PyInt_From_int(__pyx_v_nnewchgcoefs); if (unlikely(!__pyx_t_17)) __PYX_ERR(9, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_18 = __Pyx_PyInt_From_int(__pyx_v_nnewchgsides); if (unlikely(!__pyx_t_18)) __PYX_ERR(9, 350, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_19 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_19 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_19)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_19); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[15] = {__pyx_t_19, __pyx_v_constraints, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_v_result_dict}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 14+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":351 + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + * result[0] = result_dict["result"] # <<<<<<<<<<<<<< + * nfixedvars[0] = result_dict["nfixedvars"] + * naggrvars[0] = result_dict["naggrvars"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_20 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_20 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(9, 351, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_20; + + /* "src/pyscipopt/conshdlr.pxi":352 + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + * result[0] = result_dict["result"] + * nfixedvars[0] = result_dict["nfixedvars"] # <<<<<<<<<<<<<< + * naggrvars[0] = result_dict["naggrvars"] + * nchgvartypes[0] = result_dict["nchgvartypes"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nfixedvars); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 352, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nfixedvars[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":353 + * result[0] = result_dict["result"] + * nfixedvars[0] = result_dict["nfixedvars"] + * naggrvars[0] = result_dict["naggrvars"] # <<<<<<<<<<<<<< + * nchgvartypes[0] = result_dict["nchgvartypes"] + * nchgbds[0] = result_dict["nchgbds"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_naggrvars); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 353, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_naggrvars[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":354 + * nfixedvars[0] = result_dict["nfixedvars"] + * naggrvars[0] = result_dict["naggrvars"] + * nchgvartypes[0] = result_dict["nchgvartypes"] # <<<<<<<<<<<<<< + * nchgbds[0] = result_dict["nchgbds"] + * naddholes[0] = result_dict["naddholes"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nchgvartypes); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 354, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgvartypes[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":355 + * naggrvars[0] = result_dict["naggrvars"] + * nchgvartypes[0] = result_dict["nchgvartypes"] + * nchgbds[0] = result_dict["nchgbds"] # <<<<<<<<<<<<<< + * naddholes[0] = result_dict["naddholes"] + * ndelconss[0] = result_dict["ndelconss"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nchgbds); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 355, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgbds[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":356 + * nchgvartypes[0] = result_dict["nchgvartypes"] + * nchgbds[0] = result_dict["nchgbds"] + * naddholes[0] = result_dict["naddholes"] # <<<<<<<<<<<<<< + * ndelconss[0] = result_dict["ndelconss"] + * naddconss[0] = result_dict["naddconss"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_naddholes); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 356, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_naddholes[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":357 + * nchgbds[0] = result_dict["nchgbds"] + * naddholes[0] = result_dict["naddholes"] + * ndelconss[0] = result_dict["ndelconss"] # <<<<<<<<<<<<<< + * naddconss[0] = result_dict["naddconss"] + * nupgdconss[0] = result_dict["nupgdconss"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_ndelconss); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 357, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_ndelconss[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":358 + * naddholes[0] = result_dict["naddholes"] + * ndelconss[0] = result_dict["ndelconss"] + * naddconss[0] = result_dict["naddconss"] # <<<<<<<<<<<<<< + * nupgdconss[0] = result_dict["nupgdconss"] + * nchgcoefs[0] = result_dict["nchgcoefs"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_naddconss); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 358, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_naddconss[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":359 + * ndelconss[0] = result_dict["ndelconss"] + * naddconss[0] = result_dict["naddconss"] + * nupgdconss[0] = result_dict["nupgdconss"] # <<<<<<<<<<<<<< + * nchgcoefs[0] = result_dict["nchgcoefs"] + * nchgsides[0] = result_dict["nchgsides"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nupgdconss); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 359, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nupgdconss[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":360 + * naddconss[0] = result_dict["naddconss"] + * nupgdconss[0] = result_dict["nupgdconss"] + * nchgcoefs[0] = result_dict["nchgcoefs"] # <<<<<<<<<<<<<< + * nchgsides[0] = result_dict["nchgsides"] + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nchgcoefs); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 360, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 360, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgcoefs[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":361 + * nupgdconss[0] = result_dict["nupgdconss"] + * nchgcoefs[0] = result_dict["nchgcoefs"] + * nchgsides[0] = result_dict["nchgsides"] # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nchgsides); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 361, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgsides[0]) = __pyx_t_2; + + /* "src/pyscipopt/conshdlr.pxi":362 + * nchgcoefs[0] = result_dict["nchgcoefs"] + * nchgsides[0] = result_dict["nchgsides"] + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsResprop (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR* infervar, int inferinfo, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":326 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming, # <<<<<<<<<<<<<< + * int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + * int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsPresol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":364 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsResprop (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR* infervar, int inferinfo, # <<<<<<<<<<<<<< + * SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsResprop(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, CYTHON_UNUSED SCIP_CONS *__pyx_v_cons, CYTHON_UNUSED SCIP_VAR *__pyx_v_infervar, CYTHON_UNUSED int __pyx_v_inferinfo, CYTHON_UNUSED SCIP_BOUNDTYPE __pyx_v_boundtype, CYTHON_UNUSED SCIP_BDCHGIDX *__pyx_v_bdchgidx, CYTHON_UNUSED SCIP_Real __pyx_v_relaxedbd, CYTHON_UNUSED SCIP_RESULT *__pyx_v_result) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsResprop", 0); + + /* "src/pyscipopt/conshdlr.pxi":366 + * cdef SCIP_RETCODE PyConsResprop (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR* infervar, int inferinfo, + * SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyConshdlr.consresprop() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":367 + * SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consresprop() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consresprop); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":368 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consresprop() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":364 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsResprop (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR* infervar, int inferinfo, # <<<<<<<<<<<<<< + * SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsResprop", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":370 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * if cons == NULL: + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsLock(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons, SCIP_LOCKTYPE __pyx_v_locktype, int __pyx_v_nlockspos, int __pyx_v_nlocksneg) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsLock", 0); + + /* "src/pyscipopt/conshdlr.pxi":371 + * + * cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * if cons == NULL: + * PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":372 + * cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * if cons == NULL: # <<<<<<<<<<<<<< + * PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg) + * else: + */ + __pyx_t_2 = (__pyx_v_cons == NULL); + if (__pyx_t_2) { + + /* "src/pyscipopt/conshdlr.pxi":373 + * PyConshdlr = getPyConshdlr(conshdlr) + * if cons == NULL: + * PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg) # <<<<<<<<<<<<<< + * else: + * PyCons = getPyCons(cons) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_conslock); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_LOCKTYPE(__pyx_v_locktype); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_nlockspos); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nlocksneg); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_7, Py_None, __pyx_t_4, __pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_8, 4+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":372 + * cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * if cons == NULL: # <<<<<<<<<<<<<< + * PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/conshdlr.pxi":375 + * PyConshdlr.conslock(None, locktype, nlockspos, nlocksneg) + * else: + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * PyConshdlr.conslock(PyCons, locktype, nlockspos, nlocksneg) + * return SCIP_OKAY + */ + /*else*/ { + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":376 + * else: + * PyCons = getPyCons(cons) + * PyConshdlr.conslock(PyCons, locktype, nlockspos, nlocksneg) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_conslock); if (unlikely(!__pyx_t_3)) __PYX_ERR(9, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_LOCKTYPE(__pyx_v_locktype); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_nlockspos); if (unlikely(!__pyx_t_5)) __PYX_ERR(9, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_nlocksneg); if (unlikely(!__pyx_t_4)) __PYX_ERR(9, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_7, ((PyObject *)__pyx_v_PyCons), __pyx_t_6, __pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_8, 4+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/conshdlr.pxi":377 + * PyCons = getPyCons(cons) + * PyConshdlr.conslock(PyCons, locktype, nlockspos, nlocksneg) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":370 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsLock (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * if cons == NULL: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsLock", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":379 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsActive(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsActive", 0); + + /* "src/pyscipopt/conshdlr.pxi":380 + * + * cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyCons = getPyCons(cons) + * PyConshdlr.consactive(PyCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":381 + * cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * PyConshdlr.consactive(PyCons) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":382 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + * PyConshdlr.consactive(PyCons) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consactive); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PyCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":383 + * PyCons = getPyCons(cons) + * PyConshdlr.consactive(PyCons) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsDeactive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":379 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsActive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsActive", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":385 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsDeactive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsDeactive(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsDeactive", 0); + + /* "src/pyscipopt/conshdlr.pxi":386 + * + * cdef SCIP_RETCODE PyConsDeactive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyCons = getPyCons(cons) + * PyConshdlr.consdeactive(PyCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":387 + * cdef SCIP_RETCODE PyConsDeactive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * PyConshdlr.consdeactive(PyCons) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":388 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + * PyConshdlr.consdeactive(PyCons) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consdeactive); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PyCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":389 + * PyCons = getPyCons(cons) + * PyConshdlr.consdeactive(PyCons) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsEnable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":385 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsDeactive (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsDeactive", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":391 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsEnable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsEnable(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsEnable", 0); + + /* "src/pyscipopt/conshdlr.pxi":392 + * + * cdef SCIP_RETCODE PyConsEnable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyCons = getPyCons(cons) + * PyConshdlr.consenable(PyCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":393 + * cdef SCIP_RETCODE PyConsEnable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * PyConshdlr.consenable(PyCons) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":394 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + * PyConshdlr.consenable(PyCons) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consenable); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PyCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":395 + * PyCons = getPyCons(cons) + * PyConshdlr.consenable(PyCons) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":391 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsEnable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsEnable", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":397 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsDisable(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsDisable", 0); + + /* "src/pyscipopt/conshdlr.pxi":398 + * + * cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyCons = getPyCons(cons) + * PyConshdlr.consdisable(PyCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":399 + * cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * PyConshdlr.consdisable(PyCons) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":400 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + * PyConshdlr.consdisable(PyCons) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consdisable); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PyCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":401 + * PyCons = getPyCons(cons) + * PyConshdlr.consdisable(PyCons) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":397 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsDisable", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":403 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsDelvars(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + PyObject *__pyx_v_constraints = 0; + int __pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsDelvars", 0); + + /* "src/pyscipopt/conshdlr.pxi":404 + * + * cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * cdef constraints = [] + * for i in range(nconss): + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":405 + * cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] # <<<<<<<<<<<<<< + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":406 + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + * for i in range(nconss): # <<<<<<<<<<<<<< + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consdelvars(constraints) + */ + __pyx_t_2 = __pyx_v_nconss; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":407 + * cdef constraints = [] + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) # <<<<<<<<<<<<<< + * PyConshdlr.consdelvars(constraints) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons((__pyx_v_conss[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Append(__pyx_v_constraints, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(9, 407, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/conshdlr.pxi":408 + * for i in range(nconss): + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consdelvars(constraints) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consdelvars); if (unlikely(!__pyx_t_6)) __PYX_ERR(9, 408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_constraints}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_2, 1+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":409 + * constraints.append(getPyCons(conss[i])) + * PyConshdlr.consdelvars(constraints) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsPrint (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":403 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * cdef constraints = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsDelvars", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":411 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsPrint (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsPrint(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons, CYTHON_UNUSED FILE *__pyx_v_file) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsPrint", 0); + + /* "src/pyscipopt/conshdlr.pxi":412 + * + * cdef SCIP_RETCODE PyConsPrint (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyCons = getPyCons(cons) + * # TODO: pass file + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":413 + * cdef SCIP_RETCODE PyConsPrint (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * # TODO: pass file + * PyConshdlr.consprint(PyCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":415 + * PyCons = getPyCons(cons) + * # TODO: pass file + * PyConshdlr.consprint(PyCons) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consprint); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PyCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 415, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":416 + * # TODO: pass file + * PyConshdlr.consprint(PyCons) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsCopy (SCIP* scip, SCIP_CONS** cons, const char* name, SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":411 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsPrint (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsPrint", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":418 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsCopy (SCIP* scip, SCIP_CONS** cons, const char* name, SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr, # <<<<<<<<<<<<<< + * SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, SCIP_Bool initial, + * SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_CONS **__pyx_v_cons, CYTHON_UNUSED char const *__pyx_v_name, CYTHON_UNUSED SCIP *__pyx_v_sourcescip, SCIP_CONSHDLR *__pyx_v_sourceconshdlr, CYTHON_UNUSED SCIP_CONS *__pyx_v_sourcecons, CYTHON_UNUSED SCIP_HASHMAP *__pyx_v_varmap, CYTHON_UNUSED SCIP_HASHMAP *__pyx_v_consmap, CYTHON_UNUSED SCIP_Bool __pyx_v_initial, CYTHON_UNUSED SCIP_Bool __pyx_v_separate, CYTHON_UNUSED SCIP_Bool __pyx_v_enforce, CYTHON_UNUSED SCIP_Bool __pyx_v_check, CYTHON_UNUSED SCIP_Bool __pyx_v_propagate, CYTHON_UNUSED SCIP_Bool __pyx_v_local, CYTHON_UNUSED SCIP_Bool __pyx_v_modifiable, CYTHON_UNUSED SCIP_Bool __pyx_v_dynamic, CYTHON_UNUSED SCIP_Bool __pyx_v_removable, CYTHON_UNUSED SCIP_Bool __pyx_v_stickingatnode, CYTHON_UNUSED SCIP_Bool __pyx_v_isglobal, SCIP_Bool *__pyx_v_valid) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsCopy", 0); + + /* "src/pyscipopt/conshdlr.pxi":424 + * SCIP_Bool isglobal, SCIP_Bool* valid) noexcept with gil: + * # TODO everything! + * PyConshdlr = getPyConshdlr(sourceconshdlr) # <<<<<<<<<<<<<< + * PyConshdlr.conscopy() + * valid[0] = False + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_sourceconshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":425 + * # TODO everything! + * PyConshdlr = getPyConshdlr(sourceconshdlr) + * PyConshdlr.conscopy() # <<<<<<<<<<<<<< + * valid[0] = False + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_conscopy); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":426 + * PyConshdlr = getPyConshdlr(sourceconshdlr) + * PyConshdlr.conscopy() + * valid[0] = False # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + (__pyx_v_valid[0]) = 0; + + /* "src/pyscipopt/conshdlr.pxi":427 + * PyConshdlr.conscopy() + * valid[0] = False + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsParse (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, const char* name, const char* str, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":418 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsCopy (SCIP* scip, SCIP_CONS** cons, const char* name, SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr, # <<<<<<<<<<<<<< + * SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, SCIP_Bool initial, + * SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsCopy", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":429 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsParse (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, const char* name, const char* str, # <<<<<<<<<<<<<< + * 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, + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsParse(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, CYTHON_UNUSED SCIP_CONS **__pyx_v_cons, CYTHON_UNUSED char const *__pyx_v_name, CYTHON_UNUSED char const *__pyx_v_str, CYTHON_UNUSED SCIP_Bool __pyx_v_initial, CYTHON_UNUSED SCIP_Bool __pyx_v_separate, CYTHON_UNUSED SCIP_Bool __pyx_v_enforce, CYTHON_UNUSED SCIP_Bool __pyx_v_check, CYTHON_UNUSED SCIP_Bool __pyx_v_propagate, CYTHON_UNUSED SCIP_Bool __pyx_v_local, CYTHON_UNUSED SCIP_Bool __pyx_v_modifiable, CYTHON_UNUSED SCIP_Bool __pyx_v_dynamic, CYTHON_UNUSED SCIP_Bool __pyx_v_removable, CYTHON_UNUSED SCIP_Bool __pyx_v_stickingatnode, SCIP_Bool *__pyx_v_success) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsParse", 0); + + /* "src/pyscipopt/conshdlr.pxi":434 + * SCIP_Bool stickingatnode, SCIP_Bool* success) noexcept with gil: + * # TODO everything! + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyConshdlr.consparse() + * success[0] = False + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":435 + * # TODO everything! + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consparse() # <<<<<<<<<<<<<< + * success[0] = False + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consparse); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":436 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consparse() + * success[0] = False # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + (__pyx_v_success[0]) = 0; + + /* "src/pyscipopt/conshdlr.pxi":437 + * PyConshdlr.consparse() + * success[0] = False + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsGetvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":429 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsParse (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, const char* name, const char* str, # <<<<<<<<<<<<<< + * 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, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsParse", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":439 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success) noexcept with gil: # <<<<<<<<<<<<<< + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetvars(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons, CYTHON_UNUSED SCIP_VAR **__pyx_v_vars, CYTHON_UNUSED int __pyx_v_varssize, SCIP_Bool *__pyx_v_success) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsGetvars", 0); + + /* "src/pyscipopt/conshdlr.pxi":441 + * cdef SCIP_RETCODE PyConsGetvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success) noexcept with gil: + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyCons = getPyCons(cons) + * PyConshdlr.consgetvars(PyCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":442 + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * PyConshdlr.consgetvars(PyCons) + * success[0] = False + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":443 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + * PyConshdlr.consgetvars(PyCons) # <<<<<<<<<<<<<< + * success[0] = False + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consgetvars); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PyCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":444 + * PyCons = getPyCons(cons) + * PyConshdlr.consgetvars(PyCons) + * success[0] = False # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + (__pyx_v_success[0]) = 0; + + /* "src/pyscipopt/conshdlr.pxi":445 + * PyConshdlr.consgetvars(PyCons) + * success[0] = False + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsGetnvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":439 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success) noexcept with gil: # <<<<<<<<<<<<<< + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsGetvars", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":447 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetnvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetnvars(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, SCIP_CONS *__pyx_v_cons, int *__pyx_v_nvars, SCIP_Bool *__pyx_v_success) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_PyCons = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + SCIP_Bool __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsGetnvars", 0); + + /* "src/pyscipopt/conshdlr.pxi":448 + * + * cdef SCIP_RETCODE PyConsGetnvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyCons = getPyCons(cons) + * result_dict = PyConshdlr.consgetnvars(PyCons) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":449 + * cdef SCIP_RETCODE PyConsGetnvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success) noexcept with gil: + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) # <<<<<<<<<<<<<< + * result_dict = PyConshdlr.consgetnvars(PyCons) + * nvars[0] = result_dict.get("nvars", 0) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyCons(__pyx_v_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":450 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + * result_dict = PyConshdlr.consgetnvars(PyCons) # <<<<<<<<<<<<<< + * nvars[0] = result_dict.get("nvars", 0) + * success[0] = result_dict.get("success", False) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consgetnvars); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PyCons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":451 + * PyCons = getPyCons(cons) + * result_dict = PyConshdlr.consgetnvars(PyCons) + * nvars[0] = result_dict.get("nvars", 0) # <<<<<<<<<<<<<< + * success[0] = result_dict.get("success", False) + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(9, 451, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_nvars[0]) = __pyx_t_4; + + /* "src/pyscipopt/conshdlr.pxi":452 + * result_dict = PyConshdlr.consgetnvars(PyCons) + * nvars[0] = result_dict.get("nvars", 0) + * success[0] = result_dict.get("success", False) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(9, 452, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_success[0]) = __pyx_t_5; + + /* "src/pyscipopt/conshdlr.pxi":453 + * nvars[0] = result_dict.get("nvars", 0) + * success[0] = result_dict.get("success", False) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsGetdivebdchgs (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, SCIP_SOL* sol, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":447 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetnvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success) noexcept with gil: # <<<<<<<<<<<<<< + * PyConshdlr = getPyConshdlr(conshdlr) + * PyCons = getPyCons(cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsGetnvars", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyCons); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":455 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetdivebdchgs (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, SCIP_SOL* sol, # <<<<<<<<<<<<<< + * SCIP_Bool* success, SCIP_Bool* infeasible) noexcept with gil: + * # TODO + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetdivebdchgs(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, CYTHON_UNUSED SCIP_DIVESET *__pyx_v_diveset, CYTHON_UNUSED SCIP_SOL *__pyx_v_sol, SCIP_Bool *__pyx_v_success, SCIP_Bool *__pyx_v_infeasible) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsGetdivebdchgs", 0); + + /* "src/pyscipopt/conshdlr.pxi":458 + * SCIP_Bool* success, SCIP_Bool* infeasible) noexcept with gil: + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyConshdlr.consgetdivebdchgs() + * success[0] = False + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 458, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":459 + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consgetdivebdchgs() # <<<<<<<<<<<<<< + * success[0] = False + * infeasible[0] = False + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consgetdivebdchgs); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":460 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consgetdivebdchgs() + * success[0] = False # <<<<<<<<<<<<<< + * infeasible[0] = False + * return SCIP_OKAY + */ + (__pyx_v_success[0]) = 0; + + /* "src/pyscipopt/conshdlr.pxi":461 + * PyConshdlr.consgetdivebdchgs() + * success[0] = False + * infeasible[0] = False # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + (__pyx_v_infeasible[0]) = 0; + + /* "src/pyscipopt/conshdlr.pxi":462 + * success[0] = False + * infeasible[0] = False + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsGetPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":455 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetdivebdchgs (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, SCIP_SOL* sol, # <<<<<<<<<<<<<< + * SCIP_Bool* success, SCIP_Bool* infeasible) noexcept with gil: + * # TODO + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsGetdivebdchgs", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":464 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, # <<<<<<<<<<<<<< + * SCIP_Bool* success) noexcept with gil: + * # TODO + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetPermSymGraph(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, CYTHON_UNUSED SCIP_CONS *__pyx_v_cons, CYTHON_UNUSED SYM_GRAPH *__pyx_v_graph, SCIP_Bool *__pyx_v_success) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsGetPermSymGraph", 0); + + /* "src/pyscipopt/conshdlr.pxi":467 + * SCIP_Bool* success) noexcept with gil: + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyConshdlr.consgetpermsymgraph() + * success[0] = False + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":468 + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consgetpermsymgraph() # <<<<<<<<<<<<<< + * success[0] = False + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consgetpermsymgraph); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":469 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consgetpermsymgraph() + * success[0] = False # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + (__pyx_v_success[0]) = 0; + + /* "src/pyscipopt/conshdlr.pxi":470 + * PyConshdlr.consgetpermsymgraph() + * success[0] = False + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyConsGetSignedPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":464 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, # <<<<<<<<<<<<<< + * SCIP_Bool* success) noexcept with gil: + * # TODO + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsGetPermSymGraph", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/conshdlr.pxi":472 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetSignedPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, # <<<<<<<<<<<<<< + * SCIP_Bool* success) noexcept with gil: + * # TODO + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyConsGetSignedPermSymGraph(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CONSHDLR *__pyx_v_conshdlr, CYTHON_UNUSED SCIP_CONS *__pyx_v_cons, CYTHON_UNUSED SYM_GRAPH *__pyx_v_graph, SCIP_Bool *__pyx_v_success) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_PyConshdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyConsGetSignedPermSymGraph", 0); + + /* "src/pyscipopt/conshdlr.pxi":475 + * SCIP_Bool* success) noexcept with gil: + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) # <<<<<<<<<<<<<< + * PyConshdlr.consgetsignedpermsymgraph() + * success[0] = False + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyConshdlr(__pyx_v_conshdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyConshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":476 + * # TODO + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consgetsignedpermsymgraph() # <<<<<<<<<<<<<< + * success[0] = False + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyConshdlr), __pyx_n_s_consgetsignedpermsymgraph); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/conshdlr.pxi":477 + * PyConshdlr = getPyConshdlr(conshdlr) + * PyConshdlr.consgetsignedpermsymgraph() + * success[0] = False # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + (__pyx_v_success[0]) = 0; + + /* "src/pyscipopt/conshdlr.pxi":478 + * PyConshdlr.consgetsignedpermsymgraph() + * success[0] = False + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/conshdlr.pxi":472 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyConsGetSignedPermSymGraph (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, # <<<<<<<<<<<<<< + * SCIP_Bool* success) noexcept with gil: + * # TODO + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyConsGetSignedPermSymGraph", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyConshdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":6 + * cdef public Model model + * + * def cutselfree(self): # <<<<<<<<<<<<<< + * '''frees memory of cut selector''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_1cutselfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Cutsel_cutselfree, "Cutsel.cutselfree(self)\nfrees memory of cut selector"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Cutsel_1cutselfree = {"cutselfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_1cutselfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_cutselfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_1cutselfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("cutselfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cutselfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_cutselfree(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_cutselfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":10 + * pass + * + * def cutselinit(self): # <<<<<<<<<<<<<< + * ''' executed after the problem is transformed. use this call to initialize cut selector data.''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_3cutselinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Cutsel_2cutselinit, "Cutsel.cutselinit(self)\n executed after the problem is transformed. use this call to initialize cut selector data."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Cutsel_3cutselinit = {"cutselinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_3cutselinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_2cutselinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_3cutselinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("cutselinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cutselinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_2cutselinit(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_2cutselinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":14 + * pass + * + * def cutselexit(self): # <<<<<<<<<<<<<< + * '''executed before the transformed problem is freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_5cutselexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Cutsel_4cutselexit, "Cutsel.cutselexit(self)\nexecuted before the transformed problem is freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Cutsel_5cutselexit = {"cutselexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_5cutselexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_4cutselexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_5cutselexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("cutselexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cutselexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_4cutselexit(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_4cutselexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":18 + * pass + * + * def cutselinitsol(self): # <<<<<<<<<<<<<< + * '''executed when the presolving is finished and the branch-and-bound process is about to begin''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_7cutselinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Cutsel_6cutselinitsol, "Cutsel.cutselinitsol(self)\nexecuted when the presolving is finished and the branch-and-bound process is about to begin"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Cutsel_7cutselinitsol = {"cutselinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_7cutselinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_6cutselinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_7cutselinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("cutselinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cutselinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_6cutselinitsol(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_6cutselinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":22 + * pass + * + * def cutselexitsol(self): # <<<<<<<<<<<<<< + * '''executed before the branch-and-bound process is freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_9cutselexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Cutsel_8cutselexitsol, "Cutsel.cutselexitsol(self)\nexecuted before the branch-and-bound process is freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Cutsel_9cutselexitsol = {"cutselexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_9cutselexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_8cutselexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_9cutselexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("cutselexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "cutselexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_8cutselexitsol(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_8cutselexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":26 + * pass + * + * def cutselselect(self, cuts, forcedcuts, root, maxnselectedcuts): # <<<<<<<<<<<<<< + * '''first method called in each iteration in the main solving loop. ''' + * # this method needs to be implemented by the user + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_11cutselselect(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Cutsel_10cutselselect, "Cutsel.cutselselect(self, cuts, forcedcuts, root, maxnselectedcuts)\nfirst method called in each iteration in the main solving loop. "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Cutsel_11cutselselect = {"cutselselect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_11cutselselect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_10cutselselect}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_11cutselselect(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_cuts = 0; + CYTHON_UNUSED PyObject *__pyx_v_forcedcuts = 0; + CYTHON_UNUSED PyObject *__pyx_v_root = 0; + CYTHON_UNUSED PyObject *__pyx_v_maxnselectedcuts = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cutselselect (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cuts,&__pyx_n_s_forcedcuts,&__pyx_n_s_root,&__pyx_n_s_maxnselectedcuts,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cuts)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(10, 26, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_forcedcuts)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(10, 26, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("cutselselect", 1, 4, 4, 1); __PYX_ERR(10, 26, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_root)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(10, 26, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("cutselselect", 1, 4, 4, 2); __PYX_ERR(10, 26, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxnselectedcuts)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(10, 26, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("cutselselect", 1, 4, 4, 3); __PYX_ERR(10, 26, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "cutselselect") < 0)) __PYX_ERR(10, 26, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + } + __pyx_v_cuts = values[0]; + __pyx_v_forcedcuts = values[1]; + __pyx_v_root = values[2]; + __pyx_v_maxnselectedcuts = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("cutselselect", 1, 4, 4, __pyx_nargs); __PYX_ERR(10, 26, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Cutsel.cutselselect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_10cutselselect(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self), __pyx_v_cuts, __pyx_v_forcedcuts, __pyx_v_root, __pyx_v_maxnselectedcuts); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_10cutselselect(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_cuts, CYTHON_UNUSED PyObject *__pyx_v_forcedcuts, CYTHON_UNUSED PyObject *__pyx_v_root, CYTHON_UNUSED PyObject *__pyx_v_maxnselectedcuts) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("cutselselect", 1); + + /* "src/pyscipopt/cutsel.pxi":29 + * '''first method called in each iteration in the main solving loop. ''' + * # this method needs to be implemented by the user + * return {} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/cutsel.pxi":26 + * pass + * + * def cutselselect(self, cuts, forcedcuts, root, maxnselectedcuts): # <<<<<<<<<<<<<< + * '''first method called in each iteration in the main solving loop. ''' + * # this method needs to be implemented by the user + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Cutsel.cutselselect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":4 + * #@brief Base class of the Cutsel Plugin + * cdef class Cutsel: + * cdef public Model model # <<<<<<<<<<<<<< + * + * def cutselfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Cutsel_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Cutsel_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Cutsel_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(10, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Cutsel.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Cutsel_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Cutsel_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Cutsel_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Cutsel_12__reduce_cython__, "Cutsel.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Cutsel_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_12__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_12__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, None), state + */ + /*else*/ { + __pyx_t_2 = (((PyObject *)__pyx_v_self->model) != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None + * if use_setstate: + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Cutsel); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, None), state + * else: + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Cutsel__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Cutsel); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Cutsel.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Cutsel__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Cutsel_14__setstate_cython__, "Cutsel.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Cutsel_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_14__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Cutsel_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Cutsel.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Cutsel_14__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Cutsel_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Cutsel__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Cutsel__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Cutsel__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Cutsel.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":32 + * + * + * cdef SCIP_RETCODE PyCutselCopy (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_CUTSEL *__pyx_v_cutsel) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/cutsel.pxi":33 + * + * cdef SCIP_RETCODE PyCutselCopy (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyCutselFree (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/cutsel.pxi":32 + * + * + * cdef SCIP_RETCODE PyCutselCopy (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":35 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselFree (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CUTSEL *__pyx_v_cutsel) { + SCIP_CUTSELDATA *__pyx_v_cutseldata; + struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_PyCutsel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyCutselFree", 0); + + /* "src/pyscipopt/cutsel.pxi":37 + * cdef SCIP_RETCODE PyCutselFree (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) # <<<<<<<<<<<<<< + * PyCutsel = cutseldata + * PyCutsel.cutselfree() + */ + __pyx_v_cutseldata = SCIPcutselGetData(__pyx_v_cutsel); + + /* "src/pyscipopt/cutsel.pxi":38 + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata # <<<<<<<<<<<<<< + * PyCutsel.cutselfree() + * Py_DECREF(PyCutsel) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_cutseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyCutsel = ((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":39 + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata + * PyCutsel.cutselfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyCutsel) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyCutsel), __pyx_n_s_cutselfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":40 + * PyCutsel = cutseldata + * PyCutsel.cutselfree() + * Py_DECREF(PyCutsel) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyCutsel)); + + /* "src/pyscipopt/cutsel.pxi":41 + * PyCutsel.cutselfree() + * Py_DECREF(PyCutsel) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyCutselInit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/cutsel.pxi":35 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselFree (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyCutselFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyCutsel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":43 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselInit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CUTSEL *__pyx_v_cutsel) { + SCIP_CUTSELDATA *__pyx_v_cutseldata; + struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_PyCutsel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyCutselInit", 0); + + /* "src/pyscipopt/cutsel.pxi":45 + * cdef SCIP_RETCODE PyCutselInit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) # <<<<<<<<<<<<<< + * PyCutsel = cutseldata + * PyCutsel.cutselinit() + */ + __pyx_v_cutseldata = SCIPcutselGetData(__pyx_v_cutsel); + + /* "src/pyscipopt/cutsel.pxi":46 + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata # <<<<<<<<<<<<<< + * PyCutsel.cutselinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_cutseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyCutsel = ((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":47 + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata + * PyCutsel.cutselinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyCutsel), __pyx_n_s_cutselinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":48 + * PyCutsel = cutseldata + * PyCutsel.cutselinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/cutsel.pxi":43 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselInit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyCutselInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyCutsel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":51 + * + * + * cdef SCIP_RETCODE PyCutselExit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CUTSEL *__pyx_v_cutsel) { + SCIP_CUTSELDATA *__pyx_v_cutseldata; + struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_PyCutsel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyCutselExit", 0); + + /* "src/pyscipopt/cutsel.pxi":53 + * cdef SCIP_RETCODE PyCutselExit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) # <<<<<<<<<<<<<< + * PyCutsel = cutseldata + * PyCutsel.cutselexit() + */ + __pyx_v_cutseldata = SCIPcutselGetData(__pyx_v_cutsel); + + /* "src/pyscipopt/cutsel.pxi":54 + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata # <<<<<<<<<<<<<< + * PyCutsel.cutselexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_cutseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyCutsel = ((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":55 + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata + * PyCutsel.cutselexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyCutsel), __pyx_n_s_cutselexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":56 + * PyCutsel = cutseldata + * PyCutsel.cutselexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyCutselInitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/cutsel.pxi":51 + * + * + * cdef SCIP_RETCODE PyCutselExit (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyCutselExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyCutsel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":58 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselInitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CUTSEL *__pyx_v_cutsel) { + SCIP_CUTSELDATA *__pyx_v_cutseldata; + struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_PyCutsel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyCutselInitsol", 0); + + /* "src/pyscipopt/cutsel.pxi":60 + * cdef SCIP_RETCODE PyCutselInitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) # <<<<<<<<<<<<<< + * PyCutsel = cutseldata + * PyCutsel.cutselinitsol() + */ + __pyx_v_cutseldata = SCIPcutselGetData(__pyx_v_cutsel); + + /* "src/pyscipopt/cutsel.pxi":61 + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata # <<<<<<<<<<<<<< + * PyCutsel.cutselinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_cutseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyCutsel = ((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":62 + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata + * PyCutsel.cutselinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyCutsel), __pyx_n_s_cutselinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":63 + * PyCutsel = cutseldata + * PyCutsel.cutselinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyCutselExitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/cutsel.pxi":58 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselInitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyCutselInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyCutsel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":65 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselExitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CUTSEL *__pyx_v_cutsel) { + SCIP_CUTSELDATA *__pyx_v_cutseldata; + struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_PyCutsel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyCutselExitsol", 0); + + /* "src/pyscipopt/cutsel.pxi":67 + * cdef SCIP_RETCODE PyCutselExitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) # <<<<<<<<<<<<<< + * PyCutsel = cutseldata + * PyCutsel.cutselexitsol() + */ + __pyx_v_cutseldata = SCIPcutselGetData(__pyx_v_cutsel); + + /* "src/pyscipopt/cutsel.pxi":68 + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata # <<<<<<<<<<<<<< + * PyCutsel.cutselexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_cutseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyCutsel = ((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":69 + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata + * PyCutsel.cutselexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyCutsel), __pyx_n_s_cutselexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":70 + * PyCutsel = cutseldata + * PyCutsel.cutselexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyCutselSelect (SCIP* scip, SCIP_CUTSEL* cutsel, SCIP_ROW** cuts, int ncuts, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/cutsel.pxi":65 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselExitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_CUTSELDATA* cutseldata + * cutseldata = SCIPcutselGetData(cutsel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyCutselExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyCutsel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/cutsel.pxi":72 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselSelect (SCIP* scip, SCIP_CUTSEL* cutsel, SCIP_ROW** cuts, int ncuts, # <<<<<<<<<<<<<< + * SCIP_ROW** forcedcuts, int nforcedcuts, SCIP_Bool root, int maxnselectedcuts, + * int* nselectedcuts, SCIP_RESULT* result) noexcept with gil: + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyCutselSelect(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_CUTSEL *__pyx_v_cutsel, SCIP_ROW **__pyx_v_cuts, int __pyx_v_ncuts, SCIP_ROW **__pyx_v_forcedcuts, int __pyx_v_nforcedcuts, SCIP_Bool __pyx_v_root, int __pyx_v_maxnselectedcuts, int *__pyx_v_nselectedcuts, SCIP_RESULT *__pyx_v_result) { + SCIP_CUTSELDATA *__pyx_v_cutseldata; + struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_PyCutsel = NULL; + PyObject *__pyx_v_pycuts = NULL; + PyObject *__pyx_v_pyforcedcuts = NULL; + PyObject *__pyx_v_result_dict = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_cut = NULL; + int __pyx_8genexpr9__pyx_v_i; + int __pyx_9genexpr10__pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + PyObject *(*__pyx_t_11)(PyObject *); + Py_ssize_t __pyx_t_12; + SCIP_RESULT __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyCutselSelect", 0); + + /* "src/pyscipopt/cutsel.pxi":77 + * cdef SCIP_CUTSELDATA* cutseldata + * cdef SCIP_ROW* scip_row + * cutseldata = SCIPcutselGetData(cutsel) # <<<<<<<<<<<<<< + * PyCutsel = cutseldata + * + */ + __pyx_v_cutseldata = SCIPcutselGetData(__pyx_v_cutsel); + + /* "src/pyscipopt/cutsel.pxi":78 + * cdef SCIP_ROW* scip_row + * cutseldata = SCIPcutselGetData(cutsel) + * PyCutsel = cutseldata # <<<<<<<<<<<<<< + * + * # translate cuts to python + */ + __pyx_t_1 = ((PyObject *)__pyx_v_cutseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyCutsel = ((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":81 + * + * # translate cuts to python + * pycuts = [Row.create(cuts[i]) for i in range(ncuts)] # <<<<<<<<<<<<<< + * pyforcedcuts = [Row.create(forcedcuts[i]) for i in range(nforcedcuts)] + * result_dict = PyCutsel.cutselselect(pycuts, pyforcedcuts, root, maxnselectedcuts) + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_ncuts; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_8genexpr9__pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_f_9pyscipopt_4scip_3Row_create((__pyx_v_cuts[__pyx_8genexpr9__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(10, 81, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __pyx_v_pycuts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":82 + * # translate cuts to python + * pycuts = [Row.create(cuts[i]) for i in range(ncuts)] + * pyforcedcuts = [Row.create(forcedcuts[i]) for i in range(nforcedcuts)] # <<<<<<<<<<<<<< + * result_dict = PyCutsel.cutselselect(pycuts, pyforcedcuts, root, maxnselectedcuts) + * + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_nforcedcuts; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_9genexpr10__pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_f_9pyscipopt_4scip_3Row_create((__pyx_v_forcedcuts[__pyx_9genexpr10__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(10, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __pyx_v_pyforcedcuts = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":83 + * pycuts = [Row.create(cuts[i]) for i in range(ncuts)] + * pyforcedcuts = [Row.create(forcedcuts[i]) for i in range(nforcedcuts)] + * result_dict = PyCutsel.cutselselect(pycuts, pyforcedcuts, root, maxnselectedcuts) # <<<<<<<<<<<<<< + * + * # Retrieve the sorted cuts. Note that these do not need to be returned explicitly in result_dict. + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyCutsel), __pyx_n_s_cutselselect); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_v_root); if (unlikely(!__pyx_t_6)) __PYX_ERR(10, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_maxnselectedcuts); if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_8, __pyx_v_pycuts, __pyx_v_pyforcedcuts, __pyx_t_6, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_2, 4+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":87 + * # Retrieve the sorted cuts. Note that these do not need to be returned explicitly in result_dict. + * # Pycuts could have been sorted in place in cutselselect() + * pycuts = result_dict.get('cuts', pycuts) # <<<<<<<<<<<<<< + * + * assert len(pycuts) == ncuts + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_n_u_cuts, __pyx_v_pycuts}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF_SET(__pyx_v_pycuts, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":89 + * pycuts = result_dict.get('cuts', pycuts) + * + * assert len(pycuts) == ncuts # <<<<<<<<<<<<<< + * assert len(pyforcedcuts) == nforcedcuts + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_9 = PyObject_Length(__pyx_v_pycuts); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(10, 89, __pyx_L1_error) + __pyx_t_10 = (__pyx_t_9 == __pyx_v_ncuts); + if (unlikely(!__pyx_t_10)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(10, 89, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(10, 89, __pyx_L1_error) + #endif + + /* "src/pyscipopt/cutsel.pxi":90 + * + * assert len(pycuts) == ncuts + * assert len(pyforcedcuts) == nforcedcuts # <<<<<<<<<<<<<< + * + * #sort cuts + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_9 = __Pyx_PyList_GET_SIZE(__pyx_v_pyforcedcuts); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(10, 90, __pyx_L1_error) + __pyx_t_10 = (__pyx_t_9 == __pyx_v_nforcedcuts); + if (unlikely(!__pyx_t_10)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(10, 90, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(10, 90, __pyx_L1_error) + #endif + + /* "src/pyscipopt/cutsel.pxi":93 + * + * #sort cuts + * for i,cut in enumerate(pycuts): # <<<<<<<<<<<<<< + * cuts[i] = ((cut).scip_row) + * + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_1 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_pycuts)) || PyTuple_CheckExact(__pyx_v_pycuts)) { + __pyx_t_5 = __pyx_v_pycuts; __Pyx_INCREF(__pyx_t_5); + __pyx_t_9 = 0; + __pyx_t_11 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_v_pycuts); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_11 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(10, 93, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_11)) { + if (likely(PyList_CheckExact(__pyx_t_5))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(10, 93, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(10, 93, __pyx_L1_error) + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(10, 93, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely((0 < 0))) __PYX_ERR(10, 93, __pyx_L1_error) + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_11(__pyx_t_5); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(10, 93, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_cut, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "src/pyscipopt/cutsel.pxi":94 + * #sort cuts + * for i,cut in enumerate(pycuts): + * cuts[i] = ((cut).scip_row) # <<<<<<<<<<<<<< + * + * nselectedcuts[0] = result_dict.get('nselectedcuts', 0) + */ + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(10, 94, __pyx_L1_error) + (__pyx_v_cuts[__pyx_t_12]) = ((SCIP_ROW *)((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_cut)->scip_row); + + /* "src/pyscipopt/cutsel.pxi":93 + * + * #sort cuts + * for i,cut in enumerate(pycuts): # <<<<<<<<<<<<<< + * cuts[i] = ((cut).scip_row) + * + */ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/cutsel.pxi":96 + * cuts[i] = ((cut).scip_row) + * + * nselectedcuts[0] = result_dict.get('nselectedcuts', 0) # <<<<<<<<<<<<<< + * result[0] = result_dict.get('result', result[0]) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(10, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + (__pyx_v_nselectedcuts[0]) = __pyx_t_2; + + /* "src/pyscipopt/cutsel.pxi":97 + * + * nselectedcuts[0] = result_dict.get('nselectedcuts', 0) + * result[0] = result_dict.get('result', result[0]) # <<<<<<<<<<<<<< + * + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_7)) __PYX_ERR(10, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = NULL; + __pyx_t_2 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_2 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_n_u_result, __pyx_t_7}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_2, 2+__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(10, 97, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_13 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_5); if (unlikely((__pyx_t_13 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(10, 97, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + (__pyx_v_result[0]) = __pyx_t_13; + + /* "src/pyscipopt/cutsel.pxi":99 + * result[0] = result_dict.get('result', result[0]) + * + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/cutsel.pxi":72 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyCutselSelect (SCIP* scip, SCIP_CUTSEL* cutsel, SCIP_ROW** cuts, int ncuts, # <<<<<<<<<<<<<< + * SCIP_ROW** forcedcuts, int nforcedcuts, SCIP_Bool root, int maxnselectedcuts, + * int* nselectedcuts, SCIP_RESULT* result) noexcept with gil: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_WriteUnraisable("pyscipopt.scip.PyCutselSelect", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyCutsel); + __Pyx_XDECREF(__pyx_v_pycuts); + __Pyx_XDECREF(__pyx_v_pyforcedcuts); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_cut); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":7 + * cdef public str name + * + * def eventcopy(self): # <<<<<<<<<<<<<< + * '''sets copy callback for all events of this event handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_1eventcopy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_eventcopy, "Eventhdlr.eventcopy(self)\nsets copy callback for all events of this event handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_1eventcopy = {"eventcopy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_1eventcopy, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_eventcopy}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_1eventcopy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventcopy (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("eventcopy", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "eventcopy", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_eventcopy(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_eventcopy(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventcopy", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":11 + * pass + * + * def eventfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of event handler ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_3eventfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_2eventfree, "Eventhdlr.eventfree(self)\ncalls destructor and frees memory of event handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_3eventfree = {"eventfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_3eventfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_2eventfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_3eventfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("eventfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "eventfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_2eventfree(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_2eventfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":15 + * pass + * + * def eventinit(self): # <<<<<<<<<<<<<< + * '''initializes event handler''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_5eventinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_4eventinit, "Eventhdlr.eventinit(self)\ninitializes event handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_5eventinit = {"eventinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_5eventinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_4eventinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_5eventinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("eventinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "eventinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_4eventinit(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_4eventinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":19 + * pass + * + * def eventexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of event handler''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_7eventexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_6eventexit, "Eventhdlr.eventexit(self)\ncalls exit method of event handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_7eventexit = {"eventexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_7eventexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_6eventexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_7eventexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("eventexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "eventexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_6eventexit(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_6eventexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":23 + * pass + * + * def eventinitsol(self): # <<<<<<<<<<<<<< + * '''informs event handler that the branch and bound process is being started ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_9eventinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_8eventinitsol, "Eventhdlr.eventinitsol(self)\ninforms event handler that the branch and bound process is being started "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_9eventinitsol = {"eventinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_9eventinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_8eventinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_9eventinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("eventinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "eventinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_8eventinitsol(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_8eventinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":27 + * pass + * + * def eventexitsol(self): # <<<<<<<<<<<<<< + * '''informs event handler that the branch and bound process data is being freed ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_11eventexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_10eventexitsol, "Eventhdlr.eventexitsol(self)\ninforms event handler that the branch and bound process data is being freed "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_11eventexitsol = {"eventexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_11eventexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_10eventexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_11eventexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("eventexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "eventexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_10eventexitsol(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_10eventexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":31 + * pass + * + * def eventdelete(self): # <<<<<<<<<<<<<< + * '''sets callback to free specific event data''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_13eventdelete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_12eventdelete, "Eventhdlr.eventdelete(self)\nsets callback to free specific event data"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_13eventdelete = {"eventdelete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_13eventdelete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_12eventdelete}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_13eventdelete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventdelete (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("eventdelete", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "eventdelete", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_12eventdelete(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_12eventdelete(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventdelete", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":35 + * pass + * + * def eventexec(self, event): # <<<<<<<<<<<<<< + * '''calls execution method of event handler ''' + * print("python error in eventexec: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_15eventexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_14eventexec, "Eventhdlr.eventexec(self, event)\ncalls execution method of event handler "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_15eventexec = {"eventexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_15eventexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_14eventexec}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_15eventexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_event = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eventexec (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_event,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_event)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(11, 35, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "eventexec") < 0)) __PYX_ERR(11, 35, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_event = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("eventexec", 1, 1, 1, __pyx_nargs); __PYX_ERR(11, 35, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Eventhdlr.eventexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_14eventexec(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self), __pyx_v_event); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_14eventexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_event) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("eventexec", 1); + + /* "src/pyscipopt/event.pxi":37 + * def eventexec(self, event): + * '''calls execution method of event handler ''' + * print("python error in eventexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":38 + * '''calls execution method of event handler ''' + * print("python error in eventexec: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":35 + * pass + * + * def eventexec(self, event): # <<<<<<<<<<<<<< + * '''calls execution method of event handler ''' + * print("python error in eventexec: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Eventhdlr.eventexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":4 + * #@brief Base class of the Event Handler Plugin + * cdef class Eventhdlr: + * cdef public Model model # <<<<<<<<<<<<<< + * cdef public str name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(11, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Eventhdlr.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_9Eventhdlr_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":5 + * cdef class Eventhdlr: + * cdef public Model model + * cdef public str name # <<<<<<<<<<<<<< + * + * def eventcopy(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(PyUnicode_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_value))) __PYX_ERR(11, 5, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Eventhdlr.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_9Eventhdlr_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_16__reduce_cython__, "Eventhdlr.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_16__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_16__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_16__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model, self.name) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->name)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None or self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None or self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, None), state + */ + /*else*/ { + __pyx_t_4 = (((PyObject *)__pyx_v_self->model) != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->name != ((PyObject*)Py_None)); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Eventhdlr); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, None), state + * else: + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Eventhdlr__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Eventhdlr); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Eventhdlr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Eventhdlr__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_9Eventhdlr_18__setstate_cython__, "Eventhdlr.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_9Eventhdlr_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_18__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_9Eventhdlr_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Eventhdlr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_9Eventhdlr_18__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_9Eventhdlr_18__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Eventhdlr__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Eventhdlr__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Eventhdlr__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Eventhdlr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":42 + * + * # local helper functions for the interface + * cdef Eventhdlr getPyEventhdlr(SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_EVENTHDLRDATA* eventhdlrdata + * eventhdlrdata = SCIPeventhdlrGetData(eventhdlr) + */ + +static struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_f_9pyscipopt_4scip_getPyEventhdlr(SCIP_EVENTHDLR *__pyx_v_eventhdlr) { + SCIP_EVENTHDLRDATA *__pyx_v_eventhdlrdata; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("getPyEventhdlr", 0); + + /* "src/pyscipopt/event.pxi":44 + * cdef Eventhdlr getPyEventhdlr(SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * cdef SCIP_EVENTHDLRDATA* eventhdlrdata + * eventhdlrdata = SCIPeventhdlrGetData(eventhdlr) # <<<<<<<<<<<<<< + * return eventhdlrdata + * + */ + __pyx_v_eventhdlrdata = SCIPeventhdlrGetData(__pyx_v_eventhdlr); + + /* "src/pyscipopt/event.pxi":45 + * cdef SCIP_EVENTHDLRDATA* eventhdlrdata + * eventhdlrdata = SCIPeventhdlrGetData(eventhdlr) + * return eventhdlrdata # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyEventCopy (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + */ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_eventhdlrdata)); + __pyx_r = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v_eventhdlrdata); + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":42 + * + * # local helper functions for the interface + * cdef Eventhdlr getPyEventhdlr(SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_EVENTHDLRDATA* eventhdlrdata + * eventhdlrdata = SCIPeventhdlrGetData(eventhdlr) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":47 + * return eventhdlrdata + * + * cdef SCIP_RETCODE PyEventCopy (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventcopy() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_EVENTHDLR *__pyx_v_eventhdlr) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_PyEventhdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyEventCopy", 0); + + /* "src/pyscipopt/event.pxi":48 + * + * cdef SCIP_RETCODE PyEventCopy (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) # <<<<<<<<<<<<<< + * PyEventhdlr.eventcopy() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyEventhdlr(__pyx_v_eventhdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":49 + * cdef SCIP_RETCODE PyEventCopy (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventcopy() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyEventhdlr), __pyx_n_s_eventcopy); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":50 + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventcopy() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyEventFree (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":47 + * return eventhdlrdata + * + * cdef SCIP_RETCODE PyEventCopy (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventcopy() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyEventCopy", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyEventhdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":52 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventFree (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventfree() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_EVENTHDLR *__pyx_v_eventhdlr) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_PyEventhdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyEventFree", 0); + + /* "src/pyscipopt/event.pxi":53 + * + * cdef SCIP_RETCODE PyEventFree (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) # <<<<<<<<<<<<<< + * PyEventhdlr.eventfree() + * Py_DECREF(PyEventhdlr) + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyEventhdlr(__pyx_v_eventhdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":54 + * cdef SCIP_RETCODE PyEventFree (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyEventhdlr) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyEventhdlr), __pyx_n_s_eventfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":55 + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventfree() + * Py_DECREF(PyEventhdlr) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyEventhdlr)); + + /* "src/pyscipopt/event.pxi":56 + * PyEventhdlr.eventfree() + * Py_DECREF(PyEventhdlr) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyEventInit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":52 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventFree (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventfree() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyEventFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyEventhdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":58 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventInit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventinit() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_EVENTHDLR *__pyx_v_eventhdlr) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_PyEventhdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyEventInit", 0); + + /* "src/pyscipopt/event.pxi":59 + * + * cdef SCIP_RETCODE PyEventInit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) # <<<<<<<<<<<<<< + * PyEventhdlr.eventinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyEventhdlr(__pyx_v_eventhdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":60 + * cdef SCIP_RETCODE PyEventInit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyEventhdlr), __pyx_n_s_eventinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":61 + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyEventExit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":58 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventInit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventinit() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyEventInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyEventhdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":63 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventExit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventexit() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_EVENTHDLR *__pyx_v_eventhdlr) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_PyEventhdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyEventExit", 0); + + /* "src/pyscipopt/event.pxi":64 + * + * cdef SCIP_RETCODE PyEventExit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) # <<<<<<<<<<<<<< + * PyEventhdlr.eventexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyEventhdlr(__pyx_v_eventhdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 64, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":65 + * cdef SCIP_RETCODE PyEventExit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyEventhdlr), __pyx_n_s_eventexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":66 + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyEventInitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":63 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventExit (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventexit() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyEventExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyEventhdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":68 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventInitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventinitsol() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_EVENTHDLR *__pyx_v_eventhdlr) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_PyEventhdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyEventInitsol", 0); + + /* "src/pyscipopt/event.pxi":69 + * + * cdef SCIP_RETCODE PyEventInitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) # <<<<<<<<<<<<<< + * PyEventhdlr.eventinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyEventhdlr(__pyx_v_eventhdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":70 + * cdef SCIP_RETCODE PyEventInitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyEventhdlr), __pyx_n_s_eventinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":71 + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyEventExitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":68 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventInitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventinitsol() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyEventInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyEventhdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":73 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventExitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventexitsol() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_EVENTHDLR *__pyx_v_eventhdlr) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_PyEventhdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyEventExitsol", 0); + + /* "src/pyscipopt/event.pxi":74 + * + * cdef SCIP_RETCODE PyEventExitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) # <<<<<<<<<<<<<< + * PyEventhdlr.eventexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyEventhdlr(__pyx_v_eventhdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 74, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":75 + * cdef SCIP_RETCODE PyEventExitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyEventhdlr), __pyx_n_s_eventexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":76 + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyEventDelete (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENTDATA** eventdata) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":73 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventExitsol (SCIP* scip, SCIP_EVENTHDLR* eventhdlr) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventexitsol() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyEventExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyEventhdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":78 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventDelete (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENTDATA** eventdata) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventdelete() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventDelete(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_EVENTHDLR *__pyx_v_eventhdlr, CYTHON_UNUSED SCIP_EVENTDATA **__pyx_v_eventdata) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_PyEventhdlr = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyEventDelete", 0); + + /* "src/pyscipopt/event.pxi":79 + * + * cdef SCIP_RETCODE PyEventDelete (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENTDATA** eventdata) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) # <<<<<<<<<<<<<< + * PyEventhdlr.eventdelete() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyEventhdlr(__pyx_v_eventhdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":80 + * cdef SCIP_RETCODE PyEventDelete (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENTDATA** eventdata) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventdelete() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyEventhdlr), __pyx_n_s_eventdelete); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":81 + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventdelete() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyEventExec (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENT* event, SCIP_EVENTDATA* eventdata) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":78 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventDelete (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENTDATA** eventdata) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEventhdlr.eventdelete() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyEventDelete", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyEventhdlr); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/event.pxi":83 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventExec (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENT* event, SCIP_EVENTDATA* eventdata) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEvent = Event() + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyEventExec(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_EVENTHDLR *__pyx_v_eventhdlr, SCIP_EVENT *__pyx_v_event, CYTHON_UNUSED SCIP_EVENTDATA *__pyx_v_eventdata) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_PyEventhdlr = NULL; + struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_PyEvent = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyEventExec", 0); + + /* "src/pyscipopt/event.pxi":84 + * + * cdef SCIP_RETCODE PyEventExec (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENT* event, SCIP_EVENTDATA* eventdata) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) # <<<<<<<<<<<<<< + * PyEvent = Event() + * PyEvent.event = event + */ + __pyx_t_1 = ((PyObject *)__pyx_f_9pyscipopt_4scip_getPyEventhdlr(__pyx_v_eventhdlr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":85 + * cdef SCIP_RETCODE PyEventExec (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENT* event, SCIP_EVENTDATA* eventdata) noexcept with gil: + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEvent = Event() # <<<<<<<<<<<<<< + * PyEvent.event = event + * PyEventhdlr.eventexec(PyEvent) + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event)); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyEvent = ((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":86 + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEvent = Event() + * PyEvent.event = event # <<<<<<<<<<<<<< + * PyEventhdlr.eventexec(PyEvent) + * return SCIP_OKAY + */ + __pyx_v_PyEvent->event = __pyx_v_event; + + /* "src/pyscipopt/event.pxi":87 + * PyEvent = Event() + * PyEvent.event = event + * PyEventhdlr.eventexec(PyEvent) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyEventhdlr), __pyx_n_s_eventexec); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_PyEvent)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/event.pxi":88 + * PyEvent.event = event + * PyEventhdlr.eventexec(PyEvent) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/event.pxi":83 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyEventExec (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENT* event, SCIP_EVENTDATA* eventdata) noexcept with gil: # <<<<<<<<<<<<<< + * PyEventhdlr = getPyEventhdlr(eventhdlr) + * PyEvent = Event() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyEventExec", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyEventhdlr); + __Pyx_XDECREF((PyObject *)__pyx_v_PyEvent); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":7 + * cdef public str name + * + * def heurfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of primal heuristic''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_1heurfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Heur_heurfree, "Heur.heurfree(self)\ncalls destructor and frees memory of primal heuristic"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Heur_1heurfree = {"heurfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_1heurfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_heurfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_1heurfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("heurfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "heurfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_heurfree(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_heurfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":11 + * pass + * + * def heurinit(self): # <<<<<<<<<<<<<< + * '''initializes primal heuristic''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_3heurinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Heur_2heurinit, "Heur.heurinit(self)\ninitializes primal heuristic"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Heur_3heurinit = {"heurinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_3heurinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_2heurinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_3heurinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("heurinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "heurinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_2heurinit(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_2heurinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":15 + * pass + * + * def heurexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of primal heuristic''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_5heurexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Heur_4heurexit, "Heur.heurexit(self)\ncalls exit method of primal heuristic"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Heur_5heurexit = {"heurexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_5heurexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_4heurexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_5heurexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("heurexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "heurexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_4heurexit(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_4heurexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":19 + * pass + * + * def heurinitsol(self): # <<<<<<<<<<<<<< + * '''informs primal heuristic that the branch and bound process is being started''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_7heurinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Heur_6heurinitsol, "Heur.heurinitsol(self)\ninforms primal heuristic that the branch and bound process is being started"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Heur_7heurinitsol = {"heurinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_7heurinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_6heurinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_7heurinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("heurinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "heurinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_6heurinitsol(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_6heurinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":23 + * pass + * + * def heurexitsol(self): # <<<<<<<<<<<<<< + * '''informs primal heuristic that the branch and bound process data is being freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_9heurexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Heur_8heurexitsol, "Heur.heurexitsol(self)\ninforms primal heuristic that the branch and bound process data is being freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Heur_9heurexitsol = {"heurexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_9heurexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_8heurexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_9heurexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("heurexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "heurexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_8heurexitsol(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_8heurexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":27 + * pass + * + * def heurexec(self, heurtiming, nodeinfeasible): # <<<<<<<<<<<<<< + * '''should the heuristic the executed at the given depth, frequency, timing,...''' + * print("python error in heurexec: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_11heurexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Heur_10heurexec, "Heur.heurexec(self, heurtiming, nodeinfeasible)\nshould the heuristic the executed at the given depth, frequency, timing,..."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Heur_11heurexec = {"heurexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_11heurexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_10heurexec}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_11heurexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_heurtiming = 0; + CYTHON_UNUSED PyObject *__pyx_v_nodeinfeasible = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("heurexec (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_heurtiming,&__pyx_n_s_nodeinfeasible,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_heurtiming)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(12, 27, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nodeinfeasible)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(12, 27, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("heurexec", 1, 2, 2, 1); __PYX_ERR(12, 27, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "heurexec") < 0)) __PYX_ERR(12, 27, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_heurtiming = values[0]; + __pyx_v_nodeinfeasible = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("heurexec", 1, 2, 2, __pyx_nargs); __PYX_ERR(12, 27, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Heur.heurexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_10heurexec(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self), __pyx_v_heurtiming, __pyx_v_nodeinfeasible); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_10heurexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_heurtiming, CYTHON_UNUSED PyObject *__pyx_v_nodeinfeasible) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("heurexec", 1); + + /* "src/pyscipopt/heuristic.pxi":29 + * def heurexec(self, heurtiming, nodeinfeasible): + * '''should the heuristic the executed at the given depth, frequency, timing,...''' + * print("python error in heurexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":30 + * '''should the heuristic the executed at the given depth, frequency, timing,...''' + * print("python error in heurexec: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/heuristic.pxi":27 + * pass + * + * def heurexec(self, heurtiming, nodeinfeasible): # <<<<<<<<<<<<<< + * '''should the heuristic the executed at the given depth, frequency, timing,...''' + * print("python error in heurexec: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Heur.heurexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":4 + * #@brief Base class of the Heuristics Plugin + * cdef class Heur: + * cdef public Model model # <<<<<<<<<<<<<< + * cdef public str name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Heur_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Heur_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Heur_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(12, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Heur.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Heur_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Heur_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Heur_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":5 + * cdef class Heur: + * cdef public Model model + * cdef public str name # <<<<<<<<<<<<<< + * + * def heurfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Heur_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Heur_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_4name_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Heur_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(PyUnicode_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_value))) __PYX_ERR(12, 5, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Heur.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Heur_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Heur_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_4name_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Heur_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Heur_12__reduce_cython__, "Heur.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Heur_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_12__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_12__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model, self.name) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->name)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None or self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None or self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, None), state + */ + /*else*/ { + __pyx_t_4 = (((PyObject *)__pyx_v_self->model) != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->name != ((PyObject*)Py_None)); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Heur); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, None), state + * else: + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Heur__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Heur); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Heur.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Heur__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Heur_14__setstate_cython__, "Heur.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Heur_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_14__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Heur_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Heur.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Heur_14__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Heur_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Heur__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Heur__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Heur__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Heur.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":34 + * + * + * cdef SCIP_RETCODE PyHeurCopy (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_HEUR *__pyx_v_heur) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/heuristic.pxi":35 + * + * cdef SCIP_RETCODE PyHeurCopy (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyHeurFree (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/heuristic.pxi":34 + * + * + * cdef SCIP_RETCODE PyHeurCopy (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":37 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurFree (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_HEUR *__pyx_v_heur) { + SCIP_HEURDATA *__pyx_v_heurdata; + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_PyHeur = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyHeurFree", 0); + + /* "src/pyscipopt/heuristic.pxi":39 + * cdef SCIP_RETCODE PyHeurFree (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) # <<<<<<<<<<<<<< + * PyHeur = heurdata + * PyHeur.heurfree() + */ + __pyx_v_heurdata = SCIPheurGetData(__pyx_v_heur); + + /* "src/pyscipopt/heuristic.pxi":40 + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata # <<<<<<<<<<<<<< + * PyHeur.heurfree() + * Py_DECREF(PyHeur) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_heurdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyHeur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":41 + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata + * PyHeur.heurfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyHeur) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyHeur), __pyx_n_s_heurfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":42 + * PyHeur = heurdata + * PyHeur.heurfree() + * Py_DECREF(PyHeur) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyHeur)); + + /* "src/pyscipopt/heuristic.pxi":43 + * PyHeur.heurfree() + * Py_DECREF(PyHeur) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyHeurInit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/heuristic.pxi":37 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurFree (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyHeurFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyHeur); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":45 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurInit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_HEUR *__pyx_v_heur) { + SCIP_HEURDATA *__pyx_v_heurdata; + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_PyHeur = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyHeurInit", 0); + + /* "src/pyscipopt/heuristic.pxi":47 + * cdef SCIP_RETCODE PyHeurInit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) # <<<<<<<<<<<<<< + * PyHeur = heurdata + * PyHeur.heurinit() + */ + __pyx_v_heurdata = SCIPheurGetData(__pyx_v_heur); + + /* "src/pyscipopt/heuristic.pxi":48 + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata # <<<<<<<<<<<<<< + * PyHeur.heurinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_heurdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyHeur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":49 + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata + * PyHeur.heurinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyHeur), __pyx_n_s_heurinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":50 + * PyHeur = heurdata + * PyHeur.heurinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyHeurExit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/heuristic.pxi":45 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurInit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyHeurInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyHeur); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":52 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurExit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_HEUR *__pyx_v_heur) { + SCIP_HEURDATA *__pyx_v_heurdata; + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_PyHeur = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyHeurExit", 0); + + /* "src/pyscipopt/heuristic.pxi":54 + * cdef SCIP_RETCODE PyHeurExit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) # <<<<<<<<<<<<<< + * PyHeur = heurdata + * PyHeur.heurexit() + */ + __pyx_v_heurdata = SCIPheurGetData(__pyx_v_heur); + + /* "src/pyscipopt/heuristic.pxi":55 + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata # <<<<<<<<<<<<<< + * PyHeur.heurexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_heurdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyHeur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":56 + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata + * PyHeur.heurexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyHeur), __pyx_n_s_heurexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":57 + * PyHeur = heurdata + * PyHeur.heurexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyHeurInitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/heuristic.pxi":52 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurExit (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyHeurExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyHeur); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":59 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurInitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_HEUR *__pyx_v_heur) { + SCIP_HEURDATA *__pyx_v_heurdata; + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_PyHeur = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyHeurInitsol", 0); + + /* "src/pyscipopt/heuristic.pxi":61 + * cdef SCIP_RETCODE PyHeurInitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) # <<<<<<<<<<<<<< + * PyHeur = heurdata + * PyHeur.heurinitsol() + */ + __pyx_v_heurdata = SCIPheurGetData(__pyx_v_heur); + + /* "src/pyscipopt/heuristic.pxi":62 + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata # <<<<<<<<<<<<<< + * PyHeur.heurinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_heurdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyHeur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":63 + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata + * PyHeur.heurinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyHeur), __pyx_n_s_heurinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":64 + * PyHeur = heurdata + * PyHeur.heurinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyHeurExitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/heuristic.pxi":59 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurInitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyHeurInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyHeur); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":66 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurExitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_HEUR *__pyx_v_heur) { + SCIP_HEURDATA *__pyx_v_heurdata; + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_PyHeur = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyHeurExitsol", 0); + + /* "src/pyscipopt/heuristic.pxi":68 + * cdef SCIP_RETCODE PyHeurExitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) # <<<<<<<<<<<<<< + * PyHeur = heurdata + * PyHeur.heurexitsol() + */ + __pyx_v_heurdata = SCIPheurGetData(__pyx_v_heur); + + /* "src/pyscipopt/heuristic.pxi":69 + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata # <<<<<<<<<<<<<< + * PyHeur.heurexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_heurdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyHeur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":70 + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata + * PyHeur.heurexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyHeur), __pyx_n_s_heurexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":71 + * PyHeur = heurdata + * PyHeur.heurexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyHeurExec (SCIP* scip, SCIP_HEUR* heur, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/heuristic.pxi":66 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurExitsol (SCIP* scip, SCIP_HEUR* heur) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyHeurExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyHeur); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/heuristic.pxi":73 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurExec (SCIP* scip, SCIP_HEUR* heur, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyHeurExec(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_HEUR *__pyx_v_heur, SCIP_HEURTIMING __pyx_v_heurtiming, SCIP_Bool __pyx_v_nodeinfeasible, SCIP_RESULT *__pyx_v_result) { + SCIP_HEURDATA *__pyx_v_heurdata; + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_PyHeur = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + SCIP_RESULT __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyHeurExec", 0); + + /* "src/pyscipopt/heuristic.pxi":75 + * cdef SCIP_RETCODE PyHeurExec (SCIP* scip, SCIP_HEUR* heur, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) # <<<<<<<<<<<<<< + * PyHeur = heurdata + * result_dict = PyHeur.heurexec(heurtiming, nodeinfeasible) + */ + __pyx_v_heurdata = SCIPheurGetData(__pyx_v_heur); + + /* "src/pyscipopt/heuristic.pxi":76 + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata # <<<<<<<<<<<<<< + * result_dict = PyHeur.heurexec(heurtiming, nodeinfeasible) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_heurdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyHeur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":77 + * heurdata = SCIPheurGetData(heur) + * PyHeur = heurdata + * result_dict = PyHeur.heurexec(heurtiming, nodeinfeasible) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyHeur), __pyx_n_s_heurexec); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_HEURTIMING(__pyx_v_heurtiming); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_nodeinfeasible); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 77, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/heuristic.pxi":78 + * PyHeur = heurdata + * result_dict = PyHeur.heurexec(heurtiming, nodeinfeasible) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_n_u_result, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_7 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_7 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(12, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_7; + + /* "src/pyscipopt/heuristic.pxi":79 + * result_dict = PyHeur.heurexec(heurtiming, nodeinfeasible) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/heuristic.pxi":73 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyHeurExec (SCIP* scip, SCIP_HEUR* heur, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_HEURDATA* heurdata + * heurdata = SCIPheurGetData(heur) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pyscipopt.scip.PyHeurExec", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyHeur); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":6 + * cdef public Model model + * + * def presolfree(self): # <<<<<<<<<<<<<< + * '''frees memory of presolver''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_1presolfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Presol_presolfree, "Presol.presolfree(self)\nfrees memory of presolver"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Presol_1presolfree = {"presolfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_1presolfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_presolfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_1presolfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("presolfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "presolfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_presolfree(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_presolfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":10 + * pass + * + * def presolinit(self): # <<<<<<<<<<<<<< + * '''initializes presolver''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_3presolinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Presol_2presolinit, "Presol.presolinit(self)\ninitializes presolver"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Presol_3presolinit = {"presolinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_3presolinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_2presolinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_3presolinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("presolinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "presolinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_2presolinit(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_2presolinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":14 + * pass + * + * def presolexit(self): # <<<<<<<<<<<<<< + * '''deinitializes presolver''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_5presolexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Presol_4presolexit, "Presol.presolexit(self)\ndeinitializes presolver"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Presol_5presolexit = {"presolexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_5presolexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_4presolexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_5presolexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("presolexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "presolexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_4presolexit(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_4presolexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":18 + * pass + * + * def presolinitpre(self): # <<<<<<<<<<<<<< + * '''informs presolver that the presolving process is being started''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_7presolinitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Presol_6presolinitpre, "Presol.presolinitpre(self)\ninforms presolver that the presolving process is being started"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Presol_7presolinitpre = {"presolinitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_7presolinitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_6presolinitpre}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_7presolinitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolinitpre (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("presolinitpre", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "presolinitpre", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_6presolinitpre(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_6presolinitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolinitpre", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":22 + * pass + * + * def presolexitpre(self): # <<<<<<<<<<<<<< + * '''informs presolver that the presolving process is finished''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_9presolexitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Presol_8presolexitpre, "Presol.presolexitpre(self)\ninforms presolver that the presolving process is finished"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Presol_9presolexitpre = {"presolexitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_9presolexitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_8presolexitpre}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_9presolexitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolexitpre (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("presolexitpre", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "presolexitpre", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_8presolexitpre(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_8presolexitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolexitpre", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":26 + * pass + * + * def presolexec(self, nrounds, presoltiming): # <<<<<<<<<<<<<< + * '''executes presolver''' + * print("python error in presolexec: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_11presolexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Presol_10presolexec, "Presol.presolexec(self, nrounds, presoltiming)\nexecutes presolver"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Presol_11presolexec = {"presolexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_11presolexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_10presolexec}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_11presolexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_nrounds = 0; + CYTHON_UNUSED PyObject *__pyx_v_presoltiming = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolexec (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nrounds,&__pyx_n_s_presoltiming,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nrounds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 26, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_presoltiming)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(13, 26, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("presolexec", 1, 2, 2, 1); __PYX_ERR(13, 26, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "presolexec") < 0)) __PYX_ERR(13, 26, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_nrounds = values[0]; + __pyx_v_presoltiming = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("presolexec", 1, 2, 2, __pyx_nargs); __PYX_ERR(13, 26, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Presol.presolexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_10presolexec(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self), __pyx_v_nrounds, __pyx_v_presoltiming); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_10presolexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_nrounds, CYTHON_UNUSED PyObject *__pyx_v_presoltiming) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("presolexec", 1); + + /* "src/pyscipopt/presol.pxi":28 + * def presolexec(self, nrounds, presoltiming): + * '''executes presolver''' + * print("python error in presolexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":29 + * '''executes presolver''' + * print("python error in presolexec: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/presol.pxi":26 + * pass + * + * def presolexec(self, nrounds, presoltiming): # <<<<<<<<<<<<<< + * '''executes presolver''' + * print("python error in presolexec: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Presol.presolexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":4 + * #@brief Base class of the Presolver Plugin + * cdef class Presol: + * cdef public Model model # <<<<<<<<<<<<<< + * + * def presolfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Presol_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Presol_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Presol_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(13, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Presol.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Presol_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Presol_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Presol_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Presol_12__reduce_cython__, "Presol.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Presol_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_12__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_12__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, None), state + */ + /*else*/ { + __pyx_t_2 = (((PyObject *)__pyx_v_self->model) != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None + * if use_setstate: + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Presol); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, None), state + * else: + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Presol__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Presol); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Presol.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Presol__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Presol_14__setstate_cython__, "Presol.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Presol_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_14__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Presol_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Presol.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Presol_14__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Presol_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Presol__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Presol__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Presol__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Presol.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":33 + * + * + * cdef SCIP_RETCODE PyPresolCopy (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_PRESOL *__pyx_v_presol) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/presol.pxi":34 + * + * cdef SCIP_RETCODE PyPresolCopy (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPresolFree (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/presol.pxi":33 + * + * + * cdef SCIP_RETCODE PyPresolCopy (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":36 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolFree (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRESOL *__pyx_v_presol) { + SCIP_PRESOLDATA *__pyx_v_presoldata; + struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_PyPresol = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPresolFree", 0); + + /* "src/pyscipopt/presol.pxi":38 + * cdef SCIP_RETCODE PyPresolFree (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) # <<<<<<<<<<<<<< + * PyPresol = presoldata + * PyPresol.presolfree() + */ + __pyx_v_presoldata = SCIPpresolGetData(__pyx_v_presol); + + /* "src/pyscipopt/presol.pxi":39 + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata # <<<<<<<<<<<<<< + * PyPresol.presolfree() + * Py_DECREF(PyPresol) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_presoldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPresol = ((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":40 + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata + * PyPresol.presolfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyPresol) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPresol), __pyx_n_s_presolfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":41 + * PyPresol = presoldata + * PyPresol.presolfree() + * Py_DECREF(PyPresol) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyPresol)); + + /* "src/pyscipopt/presol.pxi":42 + * PyPresol.presolfree() + * Py_DECREF(PyPresol) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPresolInit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/presol.pxi":36 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolFree (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPresolFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPresol); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":44 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolInit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRESOL *__pyx_v_presol) { + SCIP_PRESOLDATA *__pyx_v_presoldata; + struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_PyPresol = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPresolInit", 0); + + /* "src/pyscipopt/presol.pxi":46 + * cdef SCIP_RETCODE PyPresolInit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) # <<<<<<<<<<<<<< + * PyPresol = presoldata + * PyPresol.presolinit() + */ + __pyx_v_presoldata = SCIPpresolGetData(__pyx_v_presol); + + /* "src/pyscipopt/presol.pxi":47 + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata # <<<<<<<<<<<<<< + * PyPresol.presolinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_presoldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPresol = ((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":48 + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata + * PyPresol.presolinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPresol), __pyx_n_s_presolinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":49 + * PyPresol = presoldata + * PyPresol.presolinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPresolExit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/presol.pxi":44 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolInit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPresolInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPresol); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":51 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolExit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRESOL *__pyx_v_presol) { + SCIP_PRESOLDATA *__pyx_v_presoldata; + struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_PyPresol = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPresolExit", 0); + + /* "src/pyscipopt/presol.pxi":53 + * cdef SCIP_RETCODE PyPresolExit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) # <<<<<<<<<<<<<< + * PyPresol = presoldata + * PyPresol.presolexit() + */ + __pyx_v_presoldata = SCIPpresolGetData(__pyx_v_presol); + + /* "src/pyscipopt/presol.pxi":54 + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata # <<<<<<<<<<<<<< + * PyPresol.presolexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_presoldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPresol = ((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":55 + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata + * PyPresol.presolexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPresol), __pyx_n_s_presolexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":56 + * PyPresol = presoldata + * PyPresol.presolexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/presol.pxi":51 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolExit (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPresolExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPresol); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":59 + * + * + * cdef SCIP_RETCODE PyPresolInitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolInitpre(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRESOL *__pyx_v_presol) { + SCIP_PRESOLDATA *__pyx_v_presoldata; + struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_PyPresol = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPresolInitpre", 0); + + /* "src/pyscipopt/presol.pxi":61 + * cdef SCIP_RETCODE PyPresolInitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) # <<<<<<<<<<<<<< + * PyPresol = presoldata + * PyPresol.presolinitpre() + */ + __pyx_v_presoldata = SCIPpresolGetData(__pyx_v_presol); + + /* "src/pyscipopt/presol.pxi":62 + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata # <<<<<<<<<<<<<< + * PyPresol.presolinitpre() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_presoldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPresol = ((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":63 + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata + * PyPresol.presolinitpre() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPresol), __pyx_n_s_presolinitpre); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":64 + * PyPresol = presoldata + * PyPresol.presolinitpre() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPresolExitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/presol.pxi":59 + * + * + * cdef SCIP_RETCODE PyPresolInitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPresolInitpre", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPresol); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":66 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolExitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolExitpre(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRESOL *__pyx_v_presol) { + SCIP_PRESOLDATA *__pyx_v_presoldata; + struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_PyPresol = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPresolExitpre", 0); + + /* "src/pyscipopt/presol.pxi":68 + * cdef SCIP_RETCODE PyPresolExitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) # <<<<<<<<<<<<<< + * PyPresol = presoldata + * PyPresol.presolexitpre() + */ + __pyx_v_presoldata = SCIPpresolGetData(__pyx_v_presol); + + /* "src/pyscipopt/presol.pxi":69 + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata # <<<<<<<<<<<<<< + * PyPresol.presolexitpre() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_presoldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPresol = ((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":70 + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata + * PyPresol.presolexitpre() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPresol), __pyx_n_s_presolexitpre); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 70, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":71 + * PyPresol = presoldata + * PyPresol.presolexitpre() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPresolExec (SCIP* scip, SCIP_PRESOL* presol, int nrounds, SCIP_PRESOLTIMING presoltiming, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/presol.pxi":66 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolExitpre (SCIP* scip, SCIP_PRESOL* presol) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPresolExitpre", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPresol); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/presol.pxi":73 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolExec (SCIP* scip, SCIP_PRESOL* presol, int nrounds, SCIP_PRESOLTIMING presoltiming, # <<<<<<<<<<<<<< + * int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + * int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPresolExec(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRESOL *__pyx_v_presol, int __pyx_v_nrounds, SCIP_PRESOLTIMING __pyx_v_presoltiming, CYTHON_UNUSED int __pyx_v_nnewfixedvars, CYTHON_UNUSED int __pyx_v_nnewaggrvars, CYTHON_UNUSED int __pyx_v_nnewchgvartypes, CYTHON_UNUSED int __pyx_v_nnewchgbds, CYTHON_UNUSED int __pyx_v_nnewholes, CYTHON_UNUSED int __pyx_v_nnewdelconss, CYTHON_UNUSED int __pyx_v_nnewaddconss, CYTHON_UNUSED int __pyx_v_nnewupgdconss, CYTHON_UNUSED int __pyx_v_nnewchgcoefs, CYTHON_UNUSED int __pyx_v_nnewchgsides, int *__pyx_v_nfixedvars, int *__pyx_v_naggrvars, int *__pyx_v_nchgvartypes, int *__pyx_v_nchgbds, int *__pyx_v_naddholes, int *__pyx_v_ndelconss, int *__pyx_v_naddconss, int *__pyx_v_nupgdconss, int *__pyx_v_nchgcoefs, int *__pyx_v_nchgsides, SCIP_RESULT *__pyx_v_result) { + SCIP_PRESOLDATA *__pyx_v_presoldata; + struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_PyPresol = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + SCIP_RESULT __pyx_t_7; + long __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPresolExec", 0); + + /* "src/pyscipopt/presol.pxi":79 + * int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) # <<<<<<<<<<<<<< + * PyPresol = presoldata + * result_dict = PyPresol.presolexec(nrounds, presoltiming) + */ + __pyx_v_presoldata = SCIPpresolGetData(__pyx_v_presol); + + /* "src/pyscipopt/presol.pxi":80 + * cdef SCIP_PRESOLDATA* presoldata + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata # <<<<<<<<<<<<<< + * result_dict = PyPresol.presolexec(nrounds, presoltiming) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_presoldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPresol = ((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":81 + * presoldata = SCIPpresolGetData(presol) + * PyPresol = presoldata + * result_dict = PyPresol.presolexec(nrounds, presoltiming) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * nfixedvars[0] += result_dict.get("nnewfixedvars", 0) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPresol), __pyx_n_s_presolexec); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nrounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(13, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(__pyx_v_presoltiming); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/presol.pxi":82 + * PyPresol = presoldata + * result_dict = PyPresol.presolexec(nrounds, presoltiming) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * nfixedvars[0] += result_dict.get("nnewfixedvars", 0) + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_n_u_result, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_7 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_7 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(13, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_7; + + /* "src/pyscipopt/presol.pxi":83 + * result_dict = PyPresol.presolexec(nrounds, presoltiming) + * result[0] = result_dict.get("result", result[0]) + * nfixedvars[0] += result_dict.get("nnewfixedvars", 0) # <<<<<<<<<<<<<< + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + */ + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nfixedvars[__pyx_t_8])); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 83, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_nfixedvars[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":84 + * result[0] = result_dict.get("result", result[0]) + * nfixedvars[0] += result_dict.get("nnewfixedvars", 0) + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) # <<<<<<<<<<<<<< + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + * nchgbds[0] += result_dict.get("nnewchgbds", 0) + */ + __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_v_naggrvars[__pyx_t_8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 84, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + (__pyx_v_naggrvars[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":85 + * nfixedvars[0] += result_dict.get("nnewfixedvars", 0) + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) # <<<<<<<<<<<<<< + * nchgbds[0] += result_dict.get("nnewchgbds", 0) + * naddholes[0] += result_dict.get("nnewaddholes", 0) + */ + __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_nchgvartypes[__pyx_t_8])); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgvartypes[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":86 + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + * nchgbds[0] += result_dict.get("nnewchgbds", 0) # <<<<<<<<<<<<<< + * naddholes[0] += result_dict.get("nnewaddholes", 0) + * ndelconss[0] += result_dict.get("nnewdelconss", 0) + */ + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgbds[__pyx_t_8])); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_nchgbds[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":87 + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + * nchgbds[0] += result_dict.get("nnewchgbds", 0) + * naddholes[0] += result_dict.get("nnewaddholes", 0) # <<<<<<<<<<<<<< + * ndelconss[0] += result_dict.get("nnewdelconss", 0) + * naddconss[0] += result_dict.get("nnewaddconss", 0) + */ + __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_v_naddholes[__pyx_t_8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + (__pyx_v_naddholes[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":88 + * nchgbds[0] += result_dict.get("nnewchgbds", 0) + * naddholes[0] += result_dict.get("nnewaddholes", 0) + * ndelconss[0] += result_dict.get("nnewdelconss", 0) # <<<<<<<<<<<<<< + * naddconss[0] += result_dict.get("nnewaddconss", 0) + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + */ + __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ndelconss[__pyx_t_8])); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 88, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_ndelconss[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":89 + * naddholes[0] += result_dict.get("nnewaddholes", 0) + * ndelconss[0] += result_dict.get("nnewdelconss", 0) + * naddconss[0] += result_dict.get("nnewaddconss", 0) # <<<<<<<<<<<<<< + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) + */ + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_naddconss[__pyx_t_8])); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_naddconss[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":90 + * ndelconss[0] += result_dict.get("nnewdelconss", 0) + * naddconss[0] += result_dict.get("nnewaddconss", 0) + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) # <<<<<<<<<<<<<< + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) + * nchgsides[0] += result_dict.get("nnewchgsides", 0) + */ + __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_v_nupgdconss[__pyx_t_8])); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + (__pyx_v_nupgdconss[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":91 + * naddconss[0] += result_dict.get("nnewaddconss", 0) + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) # <<<<<<<<<<<<<< + * nchgsides[0] += result_dict.get("nnewchgsides", 0) + * return SCIP_OKAY + */ + __pyx_t_8 = 0; + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_nchgcoefs[__pyx_t_8])); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 91, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgcoefs[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":92 + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) + * nchgsides[0] += result_dict.get("nnewchgsides", 0) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_8 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgsides[__pyx_t_8])); if (unlikely(!__pyx_t_1)) __PYX_ERR(13, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(13, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(13, 92, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_nchgsides[__pyx_t_8]) = __pyx_t_6; + + /* "src/pyscipopt/presol.pxi":93 + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) + * nchgsides[0] += result_dict.get("nnewchgsides", 0) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/presol.pxi":73 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPresolExec (SCIP* scip, SCIP_PRESOL* presol, int nrounds, SCIP_PRESOLTIMING presoltiming, # <<<<<<<<<<<<<< + * int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + * int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPresolExec", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPresol); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":6 + * cdef public Model model + * + * def pricerfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of variable pricer ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_1pricerfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_pricerfree, "Pricer.pricerfree(self)\ncalls destructor and frees memory of variable pricer "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_1pricerfree = {"pricerfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_1pricerfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_pricerfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_1pricerfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("pricerfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "pricerfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_pricerfree(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_pricerfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":10 + * pass + * + * def pricerinit(self): # <<<<<<<<<<<<<< + * '''initializes variable pricer''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_3pricerinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_2pricerinit, "Pricer.pricerinit(self)\ninitializes variable pricer"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_3pricerinit = {"pricerinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_3pricerinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_2pricerinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_3pricerinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("pricerinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "pricerinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_2pricerinit(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_2pricerinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":14 + * pass + * + * def pricerexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of variable pricer''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_5pricerexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_4pricerexit, "Pricer.pricerexit(self)\ncalls exit method of variable pricer"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_5pricerexit = {"pricerexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_5pricerexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_4pricerexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_5pricerexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("pricerexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "pricerexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_4pricerexit(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_4pricerexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":18 + * pass + * + * def pricerinitsol(self): # <<<<<<<<<<<<<< + * '''informs variable pricer that the branch and bound process is being started ''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_7pricerinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_6pricerinitsol, "Pricer.pricerinitsol(self)\ninforms variable pricer that the branch and bound process is being started "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_7pricerinitsol = {"pricerinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_7pricerinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_6pricerinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_7pricerinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("pricerinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "pricerinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_6pricerinitsol(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_6pricerinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":22 + * pass + * + * def pricerexitsol(self): # <<<<<<<<<<<<<< + * '''informs variable pricer that the branch and bound process data is being freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_9pricerexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_8pricerexitsol, "Pricer.pricerexitsol(self)\ninforms variable pricer that the branch and bound process data is being freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_9pricerexitsol = {"pricerexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_9pricerexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_8pricerexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_9pricerexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("pricerexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "pricerexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_8pricerexitsol(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_8pricerexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":26 + * pass + * + * def pricerredcost(self): # <<<<<<<<<<<<<< + * '''calls reduced cost pricing method of variable pricer''' + * raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_11pricerredcost(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_10pricerredcost, "Pricer.pricerredcost(self)\ncalls reduced cost pricing method of variable pricer"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_11pricerredcost = {"pricerredcost", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_11pricerredcost, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_10pricerredcost}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_11pricerredcost(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerredcost (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("pricerredcost", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "pricerredcost", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_10pricerredcost(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_10pricerredcost(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pricerredcost", 1); + + /* "src/pyscipopt/pricer.pxi":28 + * def pricerredcost(self): + * '''calls reduced cost pricing method of variable pricer''' + * raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") # <<<<<<<<<<<<<< + * + * def pricerfarkas(self): + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(14, 28, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":26 + * pass + * + * def pricerredcost(self): # <<<<<<<<<<<<<< + * '''calls reduced cost pricing method of variable pricer''' + * raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Pricer.pricerredcost", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":30 + * raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") + * + * def pricerfarkas(self): # <<<<<<<<<<<<<< + * '''calls Farkas pricing method of variable pricer''' + * raise NotImplementedError("pricerfarkas() is a fundamental callback and should be implemented in the derived class") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_13pricerfarkas(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_12pricerfarkas, "Pricer.pricerfarkas(self)\ncalls Farkas pricing method of variable pricer"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_13pricerfarkas = {"pricerfarkas", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_13pricerfarkas, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_12pricerfarkas}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_13pricerfarkas(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("pricerfarkas (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("pricerfarkas", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "pricerfarkas", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_12pricerfarkas(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_12pricerfarkas(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pricerfarkas", 1); + + /* "src/pyscipopt/pricer.pxi":32 + * def pricerfarkas(self): + * '''calls Farkas pricing method of variable pricer''' + * raise NotImplementedError("pricerfarkas() is a fundamental callback and should be implemented in the derived class") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_NotImplementedError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(14, 32, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":30 + * raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") + * + * def pricerfarkas(self): # <<<<<<<<<<<<<< + * '''calls Farkas pricing method of variable pricer''' + * raise NotImplementedError("pricerfarkas() is a fundamental callback and should be implemented in the derived class") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Pricer.pricerfarkas", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":4 + * #@brief Base class of the Pricers Plugin + * cdef class Pricer: + * cdef public Model model # <<<<<<<<<<<<<< + * + * def pricerfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Pricer_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Pricer_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Pricer_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(14, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Pricer.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Pricer_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Pricer_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Pricer_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_14__reduce_cython__, "Pricer.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_14__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_14__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_14__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, None), state + */ + /*else*/ { + __pyx_t_2 = (((PyObject *)__pyx_v_self->model) != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None + * if use_setstate: + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Pricer); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, None), state + * else: + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Pricer__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Pricer); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Pricer.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Pricer__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Pricer_16__setstate_cython__, "Pricer.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Pricer_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_16__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Pricer_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Pricer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Pricer_16__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Pricer_16__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Pricer__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Pricer__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Pricer__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Pricer.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":36 + * + * + * cdef SCIP_RETCODE PyPricerCopy (SCIP* scip, SCIP_PRICER* pricer, SCIP_Bool* valid) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_PRICER *__pyx_v_pricer, CYTHON_UNUSED SCIP_Bool *__pyx_v_valid) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/pricer.pxi":37 + * + * cdef SCIP_RETCODE PyPricerCopy (SCIP* scip, SCIP_PRICER* pricer, SCIP_Bool* valid) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPricerFree (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/pricer.pxi":36 + * + * + * cdef SCIP_RETCODE PyPricerCopy (SCIP* scip, SCIP_PRICER* pricer, SCIP_Bool* valid) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":39 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerFree (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRICER *__pyx_v_pricer) { + SCIP_PRICERDATA *__pyx_v_pricerdata; + struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_PyPricer = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPricerFree", 0); + + /* "src/pyscipopt/pricer.pxi":41 + * cdef SCIP_RETCODE PyPricerFree (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) # <<<<<<<<<<<<<< + * PyPricer = pricerdata + * PyPricer.pricerfree() + */ + __pyx_v_pricerdata = SCIPpricerGetData(__pyx_v_pricer); + + /* "src/pyscipopt/pricer.pxi":42 + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata # <<<<<<<<<<<<<< + * PyPricer.pricerfree() + * Py_DECREF(PyPricer) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_pricerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPricer = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":43 + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata + * PyPricer.pricerfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyPricer) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPricer), __pyx_n_s_pricerfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":44 + * PyPricer = pricerdata + * PyPricer.pricerfree() + * Py_DECREF(PyPricer) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyPricer)); + + /* "src/pyscipopt/pricer.pxi":45 + * PyPricer.pricerfree() + * Py_DECREF(PyPricer) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPricerInit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/pricer.pxi":39 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerFree (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPricerFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPricer); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":47 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerInit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRICER *__pyx_v_pricer) { + SCIP_PRICERDATA *__pyx_v_pricerdata; + struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_PyPricer = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPricerInit", 0); + + /* "src/pyscipopt/pricer.pxi":49 + * cdef SCIP_RETCODE PyPricerInit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) # <<<<<<<<<<<<<< + * PyPricer = pricerdata + * PyPricer.pricerinit() + */ + __pyx_v_pricerdata = SCIPpricerGetData(__pyx_v_pricer); + + /* "src/pyscipopt/pricer.pxi":50 + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata # <<<<<<<<<<<<<< + * PyPricer.pricerinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_pricerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPricer = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":51 + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata + * PyPricer.pricerinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPricer), __pyx_n_s_pricerinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":52 + * PyPricer = pricerdata + * PyPricer.pricerinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPricerExit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/pricer.pxi":47 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerInit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPricerInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPricer); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":54 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerExit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRICER *__pyx_v_pricer) { + SCIP_PRICERDATA *__pyx_v_pricerdata; + struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_PyPricer = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPricerExit", 0); + + /* "src/pyscipopt/pricer.pxi":56 + * cdef SCIP_RETCODE PyPricerExit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) # <<<<<<<<<<<<<< + * PyPricer = pricerdata + * PyPricer.pricerexit() + */ + __pyx_v_pricerdata = SCIPpricerGetData(__pyx_v_pricer); + + /* "src/pyscipopt/pricer.pxi":57 + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata # <<<<<<<<<<<<<< + * PyPricer.pricerexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_pricerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPricer = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":58 + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata + * PyPricer.pricerexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPricer), __pyx_n_s_pricerexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":59 + * PyPricer = pricerdata + * PyPricer.pricerexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPricerInitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/pricer.pxi":54 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerExit (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPricerExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPricer); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":61 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerInitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRICER *__pyx_v_pricer) { + SCIP_PRICERDATA *__pyx_v_pricerdata; + struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_PyPricer = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPricerInitsol", 0); + + /* "src/pyscipopt/pricer.pxi":63 + * cdef SCIP_RETCODE PyPricerInitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) # <<<<<<<<<<<<<< + * PyPricer = pricerdata + * PyPricer.pricerinitsol() + */ + __pyx_v_pricerdata = SCIPpricerGetData(__pyx_v_pricer); + + /* "src/pyscipopt/pricer.pxi":64 + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata # <<<<<<<<<<<<<< + * PyPricer.pricerinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_pricerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPricer = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":65 + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata + * PyPricer.pricerinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPricer), __pyx_n_s_pricerinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":66 + * PyPricer = pricerdata + * PyPricer.pricerinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPricerExitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/pricer.pxi":61 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerInitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPricerInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPricer); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":68 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerExitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRICER *__pyx_v_pricer) { + SCIP_PRICERDATA *__pyx_v_pricerdata; + struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_PyPricer = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPricerExitsol", 0); + + /* "src/pyscipopt/pricer.pxi":70 + * cdef SCIP_RETCODE PyPricerExitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) # <<<<<<<<<<<<<< + * PyPricer = pricerdata + * PyPricer.pricerexitsol() + */ + __pyx_v_pricerdata = SCIPpricerGetData(__pyx_v_pricer); + + /* "src/pyscipopt/pricer.pxi":71 + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata # <<<<<<<<<<<<<< + * PyPricer.pricerexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_pricerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPricer = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":72 + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata + * PyPricer.pricerexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPricer), __pyx_n_s_pricerexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":73 + * PyPricer = pricerdata + * PyPricer.pricerexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPricerRedcost (SCIP* scip, SCIP_PRICER* pricer, SCIP_Real* lowerbound, SCIP_Bool* stopearly, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/pricer.pxi":68 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerExitsol (SCIP* scip, SCIP_PRICER* pricer) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPricerExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPricer); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":75 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerRedcost (SCIP* scip, SCIP_PRICER* pricer, SCIP_Real* lowerbound, SCIP_Bool* stopearly, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerRedcost(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRICER *__pyx_v_pricer, SCIP_Real *__pyx_v_lowerbound, SCIP_Bool *__pyx_v_stopearly, SCIP_RESULT *__pyx_v_result) { + SCIP_PRICERDATA *__pyx_v_pricerdata; + struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_PyPricer = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + SCIP_RESULT __pyx_t_6; + SCIP_Real __pyx_t_7; + SCIP_Bool __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPricerRedcost", 0); + + /* "src/pyscipopt/pricer.pxi":77 + * cdef SCIP_RETCODE PyPricerRedcost (SCIP* scip, SCIP_PRICER* pricer, SCIP_Real* lowerbound, SCIP_Bool* stopearly, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) # <<<<<<<<<<<<<< + * PyPricer = pricerdata + * result_dict = PyPricer.pricerredcost() + */ + __pyx_v_pricerdata = SCIPpricerGetData(__pyx_v_pricer); + + /* "src/pyscipopt/pricer.pxi":78 + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata # <<<<<<<<<<<<<< + * result_dict = PyPricer.pricerredcost() + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_pricerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPricer = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":79 + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata + * result_dict = PyPricer.pricerredcost() # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPricer), __pyx_n_s_pricerredcost); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":80 + * PyPricer = pricerdata + * result_dict = PyPricer.pricerredcost() + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + * stopearly[0] = result_dict.get("stopearly", stopearly[0]) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_n_u_result, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_6 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_6 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(14, 80, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_6; + + /* "src/pyscipopt/pricer.pxi":81 + * result_dict = PyPricer.pricerredcost() + * result[0] = result_dict.get("result", result[0]) + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) # <<<<<<<<<<<<<< + * stopearly[0] = result_dict.get("stopearly", stopearly[0]) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(((SCIP_Real)(__pyx_v_lowerbound[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_n_u_lowerbound, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_7 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(14, 81, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_lowerbound[0]) = __pyx_t_7; + + /* "src/pyscipopt/pricer.pxi":82 + * result[0] = result_dict.get("result", result[0]) + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + * stopearly[0] = result_dict.get("stopearly", stopearly[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(((SCIP_Bool)(__pyx_v_stopearly[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_n_u_stopearly, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(14, 82, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_stopearly[0]) = __pyx_t_8; + + /* "src/pyscipopt/pricer.pxi":83 + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + * stopearly[0] = result_dict.get("stopearly", stopearly[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPricerFarkas (SCIP* scip, SCIP_PRICER* pricer, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/pricer.pxi":75 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerRedcost (SCIP* scip, SCIP_PRICER* pricer, SCIP_Real* lowerbound, SCIP_Bool* stopearly, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPricerRedcost", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPricer); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/pricer.pxi":85 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerFarkas (SCIP* scip, SCIP_PRICER* pricer, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPricerFarkas(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PRICER *__pyx_v_pricer, SCIP_RESULT *__pyx_v_result) { + SCIP_PRICERDATA *__pyx_v_pricerdata; + struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_PyPricer = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + SCIP_RESULT __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPricerFarkas", 0); + + /* "src/pyscipopt/pricer.pxi":87 + * cdef SCIP_RETCODE PyPricerFarkas (SCIP* scip, SCIP_PRICER* pricer, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) # <<<<<<<<<<<<<< + * PyPricer = pricerdata + * result[0] = PyPricer.pricerfarkas().get("result", result[0]) + */ + __pyx_v_pricerdata = SCIPpricerGetData(__pyx_v_pricer); + + /* "src/pyscipopt/pricer.pxi":88 + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata # <<<<<<<<<<<<<< + * result[0] = PyPricer.pricerfarkas().get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_pricerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyPricer = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/pricer.pxi":89 + * pricerdata = SCIPpricerGetData(pricer) + * PyPricer = pricerdata + * result[0] = PyPricer.pricerfarkas().get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyPricer), __pyx_n_s_pricerfarkas); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(14, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(14, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_6 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_6 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(14, 89, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_6; + + /* "src/pyscipopt/pricer.pxi":90 + * PyPricer = pricerdata + * result[0] = PyPricer.pricerfarkas().get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/pricer.pxi":85 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPricerFarkas (SCIP* scip, SCIP_PRICER* pricer, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PRICERDATA* pricerdata + * pricerdata = SCIPpricerGetData(pricer) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPricerFarkas", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyPricer); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":6 + * cdef public Model model + * + * def propfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of propagator''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_1propfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_propfree, "Prop.propfree(self)\ncalls destructor and frees memory of propagator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_1propfree = {"propfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_1propfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_propfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_1propfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("propfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "propfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_propfree(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_propfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":10 + * pass + * + * def propinit(self): # <<<<<<<<<<<<<< + * '''initializes propagator''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_3propinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_2propinit, "Prop.propinit(self)\ninitializes propagator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_3propinit = {"propinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_3propinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_2propinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_3propinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("propinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "propinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_2propinit(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_2propinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":14 + * pass + * + * def propexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of propagator''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_5propexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_4propexit, "Prop.propexit(self)\ncalls exit method of propagator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_5propexit = {"propexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_5propexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_4propexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_5propexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("propexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "propexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_4propexit(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_4propexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":18 + * pass + * + * def propinitsol(self): # <<<<<<<<<<<<<< + * '''informs propagator that the prop and bound process is being started''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_7propinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_6propinitsol, "Prop.propinitsol(self)\ninforms propagator that the prop and bound process is being started"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_7propinitsol = {"propinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_7propinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_6propinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_7propinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("propinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "propinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_6propinitsol(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_6propinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":22 + * pass + * + * def propexitsol(self, restart): # <<<<<<<<<<<<<< + * '''informs propagator that the prop and bound process data is being freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_9propexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_8propexitsol, "Prop.propexitsol(self, restart)\ninforms propagator that the prop and bound process data is being freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_9propexitsol = {"propexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_9propexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_8propexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_9propexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_restart = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_restart,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_restart)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 22, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "propexitsol") < 0)) __PYX_ERR(15, 22, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_restart = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("propexitsol", 1, 1, 1, __pyx_nargs); __PYX_ERR(15, 22, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Prop.propexitsol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_8propexitsol(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self), __pyx_v_restart); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_8propexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_restart) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":26 + * pass + * + * def propinitpre(self): # <<<<<<<<<<<<<< + * '''informs propagator that the presolving process is being started''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_11propinitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_10propinitpre, "Prop.propinitpre(self)\ninforms propagator that the presolving process is being started"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_11propinitpre = {"propinitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_11propinitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_10propinitpre}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_11propinitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propinitpre (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("propinitpre", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "propinitpre", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_10propinitpre(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_10propinitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propinitpre", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":30 + * pass + * + * def propexitpre(self): # <<<<<<<<<<<<<< + * '''informs propagator that the presolving process is finished''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_13propexitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_12propexitpre, "Prop.propexitpre(self)\ninforms propagator that the presolving process is finished"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_13propexitpre = {"propexitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_13propexitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_12propexitpre}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_13propexitpre(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propexitpre (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("propexitpre", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "propexitpre", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_12propexitpre(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_12propexitpre(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propexitpre", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":34 + * pass + * + * def proppresol(self, nrounds, presoltiming, result_dict): # <<<<<<<<<<<<<< + * '''executes presolving method of propagator''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_15proppresol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_14proppresol, "Prop.proppresol(self, nrounds, presoltiming, result_dict)\nexecutes presolving method of propagator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_15proppresol = {"proppresol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_15proppresol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_14proppresol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_15proppresol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_nrounds = 0; + CYTHON_UNUSED PyObject *__pyx_v_presoltiming = 0; + CYTHON_UNUSED PyObject *__pyx_v_result_dict = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("proppresol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nrounds,&__pyx_n_s_presoltiming,&__pyx_n_s_result_dict,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nrounds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 34, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_presoltiming)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 34, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("proppresol", 1, 3, 3, 1); __PYX_ERR(15, 34, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_result_dict)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 34, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("proppresol", 1, 3, 3, 2); __PYX_ERR(15, 34, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "proppresol") < 0)) __PYX_ERR(15, 34, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_nrounds = values[0]; + __pyx_v_presoltiming = values[1]; + __pyx_v_result_dict = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("proppresol", 1, 3, 3, __pyx_nargs); __PYX_ERR(15, 34, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Prop.proppresol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_14proppresol(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self), __pyx_v_nrounds, __pyx_v_presoltiming, __pyx_v_result_dict); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_14proppresol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_nrounds, CYTHON_UNUSED PyObject *__pyx_v_presoltiming, CYTHON_UNUSED PyObject *__pyx_v_result_dict) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("proppresol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":38 + * pass + * + * def propexec(self, proptiming): # <<<<<<<<<<<<<< + * '''calls execution method of propagator''' + * print("python error in propexec: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_17propexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_16propexec, "Prop.propexec(self, proptiming)\ncalls execution method of propagator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_17propexec = {"propexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_17propexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_16propexec}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_17propexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_proptiming = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propexec (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_proptiming,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_proptiming)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 38, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "propexec") < 0)) __PYX_ERR(15, 38, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_proptiming = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("propexec", 1, 1, 1, __pyx_nargs); __PYX_ERR(15, 38, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Prop.propexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_16propexec(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self), __pyx_v_proptiming); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_16propexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_proptiming) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("propexec", 1); + + /* "src/pyscipopt/propagator.pxi":40 + * def propexec(self, proptiming): + * '''calls execution method of propagator''' + * print("python error in propexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":41 + * '''calls execution method of propagator''' + * print("python error in propexec: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * def propresprop(self, confvar, inferinfo, bdtype, relaxedbd): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":38 + * pass + * + * def propexec(self, proptiming): # <<<<<<<<<<<<<< + * '''calls execution method of propagator''' + * print("python error in propexec: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Prop.propexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":43 + * return {} + * + * def propresprop(self, confvar, inferinfo, bdtype, relaxedbd): # <<<<<<<<<<<<<< + * '''resolves the given conflicting bound, that was reduced by the given propagator''' + * print("python error in propresprop: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_19propresprop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_18propresprop, "Prop.propresprop(self, confvar, inferinfo, bdtype, relaxedbd)\nresolves the given conflicting bound, that was reduced by the given propagator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_19propresprop = {"propresprop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_19propresprop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_18propresprop}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_19propresprop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_confvar = 0; + CYTHON_UNUSED PyObject *__pyx_v_inferinfo = 0; + CYTHON_UNUSED PyObject *__pyx_v_bdtype = 0; + CYTHON_UNUSED PyObject *__pyx_v_relaxedbd = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propresprop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_confvar,&__pyx_n_s_inferinfo,&__pyx_n_s_bdtype,&__pyx_n_s_relaxedbd,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_confvar)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 43, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_inferinfo)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 43, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("propresprop", 1, 4, 4, 1); __PYX_ERR(15, 43, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bdtype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 43, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("propresprop", 1, 4, 4, 2); __PYX_ERR(15, 43, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_relaxedbd)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(15, 43, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("propresprop", 1, 4, 4, 3); __PYX_ERR(15, 43, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "propresprop") < 0)) __PYX_ERR(15, 43, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + } + __pyx_v_confvar = values[0]; + __pyx_v_inferinfo = values[1]; + __pyx_v_bdtype = values[2]; + __pyx_v_relaxedbd = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("propresprop", 1, 4, 4, __pyx_nargs); __PYX_ERR(15, 43, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Prop.propresprop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_18propresprop(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self), __pyx_v_confvar, __pyx_v_inferinfo, __pyx_v_bdtype, __pyx_v_relaxedbd); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_18propresprop(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_confvar, CYTHON_UNUSED PyObject *__pyx_v_inferinfo, CYTHON_UNUSED PyObject *__pyx_v_bdtype, CYTHON_UNUSED PyObject *__pyx_v_relaxedbd) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("propresprop", 1); + + /* "src/pyscipopt/propagator.pxi":45 + * def propresprop(self, confvar, inferinfo, bdtype, relaxedbd): + * '''resolves the given conflicting bound, that was reduced by the given propagator''' + * print("python error in propresprop: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":46 + * '''resolves the given conflicting bound, that was reduced by the given propagator''' + * print("python error in propresprop: this method needs to be implemented") + * return {} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":43 + * return {} + * + * def propresprop(self, confvar, inferinfo, bdtype, relaxedbd): # <<<<<<<<<<<<<< + * '''resolves the given conflicting bound, that was reduced by the given propagator''' + * print("python error in propresprop: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Prop.propresprop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":4 + * #@brief Base class of the Propagators Plugin + * cdef class Prop: + * cdef public Model model # <<<<<<<<<<<<<< + * + * def propfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Prop_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Prop_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Prop_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(15, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Prop.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Prop_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Prop_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Prop_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_21__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_20__reduce_cython__, "Prop.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_21__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_21__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_20__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_21__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_20__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_20__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, None), state + */ + /*else*/ { + __pyx_t_2 = (((PyObject *)__pyx_v_self->model) != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None + * if use_setstate: + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Prop); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, None), state + * else: + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Prop__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Prop); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Prop.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Prop__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_23__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Prop_22__setstate_cython__, "Prop.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Prop_23__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_23__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_22__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Prop_23__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Prop.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Prop_22__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Prop_22__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Prop__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Prop__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Prop__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Prop.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":50 + * + * + * cdef SCIP_RETCODE PyPropCopy (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_PROP *__pyx_v_prop) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/propagator.pxi":51 + * + * cdef SCIP_RETCODE PyPropCopy (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropFree (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":50 + * + * + * cdef SCIP_RETCODE PyPropCopy (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":53 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropFree (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropFree", 0); + + /* "src/pyscipopt/propagator.pxi":55 + * cdef SCIP_RETCODE PyPropFree (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * PyProp.propfree() + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":56 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * PyProp.propfree() + * Py_DECREF(PyProp) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":57 + * propdata = SCIPpropGetData(prop) + * PyProp = propdata + * PyProp.propfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyProp) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":58 + * PyProp = propdata + * PyProp.propfree() + * Py_DECREF(PyProp) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyProp)); + + /* "src/pyscipopt/propagator.pxi":59 + * PyProp.propfree() + * Py_DECREF(PyProp) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropInit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":53 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropFree (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":61 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropInit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropInit", 0); + + /* "src/pyscipopt/propagator.pxi":63 + * cdef SCIP_RETCODE PyPropInit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * PyProp.propinit() + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":64 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * PyProp.propinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":65 + * propdata = SCIPpropGetData(prop) + * PyProp = propdata + * PyProp.propinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":66 + * PyProp = propdata + * PyProp.propinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropExit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":61 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropInit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":68 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropExit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropExit", 0); + + /* "src/pyscipopt/propagator.pxi":70 + * cdef SCIP_RETCODE PyPropExit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * PyProp.propexit() + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":71 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * PyProp.propexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":72 + * propdata = SCIPpropGetData(prop) + * PyProp = propdata + * PyProp.propexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 72, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":73 + * PyProp = propdata + * PyProp.propexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropInitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":68 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropExit (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":75 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropInitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropInitpre(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropInitpre", 0); + + /* "src/pyscipopt/propagator.pxi":77 + * cdef SCIP_RETCODE PyPropInitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * PyProp.propinitpre() + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":78 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * PyProp.propinitpre() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":79 + * propdata = SCIPpropGetData(prop) + * PyProp = propdata + * PyProp.propinitpre() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propinitpre); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":80 + * PyProp = propdata + * PyProp.propinitpre() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropExitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":75 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropInitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropInitpre", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":82 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropExitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropExitpre(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropExitpre", 0); + + /* "src/pyscipopt/propagator.pxi":84 + * cdef SCIP_RETCODE PyPropExitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * PyProp.propexitpre() + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":85 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * PyProp.propexitpre() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":86 + * propdata = SCIPpropGetData(prop) + * PyProp = propdata + * PyProp.propexitpre() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propexitpre); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":87 + * PyProp = propdata + * PyProp.propexitpre() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropInitsol (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":82 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropExitpre (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropExitpre", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":89 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropInitsol (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropInitsol", 0); + + /* "src/pyscipopt/propagator.pxi":91 + * cdef SCIP_RETCODE PyPropInitsol (SCIP* scip, SCIP_PROP* prop) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * PyProp.propinitsol() + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":92 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * PyProp.propinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":93 + * propdata = SCIPpropGetData(prop) + * PyProp = propdata + * PyProp.propinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":94 + * PyProp = propdata + * PyProp.propinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropExitsol (SCIP* scip, SCIP_PROP* prop, SCIP_Bool restart) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":89 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropInitsol (SCIP* scip, SCIP_PROP* prop) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":96 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropExitsol (SCIP* scip, SCIP_PROP* prop, SCIP_Bool restart) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop, SCIP_Bool __pyx_v_restart) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropExitsol", 0); + + /* "src/pyscipopt/propagator.pxi":98 + * cdef SCIP_RETCODE PyPropExitsol (SCIP* scip, SCIP_PROP* prop, SCIP_Bool restart) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * PyProp.propexitsol(restart) + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":99 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * PyProp.propexitsol(restart) + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":100 + * propdata = SCIPpropGetData(prop) + * PyProp = propdata + * PyProp.propexitsol(restart) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_restart); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":101 + * PyProp = propdata + * PyProp.propexitsol(restart) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropPresol (SCIP* scip, SCIP_PROP* prop, int nrounds, SCIP_PRESOLTIMING presoltiming, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":96 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropExitsol (SCIP* scip, SCIP_PROP* prop, SCIP_Bool restart) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":103 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropPresol (SCIP* scip, SCIP_PROP* prop, int nrounds, SCIP_PRESOLTIMING presoltiming, # <<<<<<<<<<<<<< + * int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + * int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropPresol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop, int __pyx_v_nrounds, SCIP_PRESOLTIMING __pyx_v_presoltiming, int __pyx_v_nnewfixedvars, int __pyx_v_nnewaggrvars, int __pyx_v_nnewchgvartypes, int __pyx_v_nnewchgbds, int __pyx_v_nnewholes, int __pyx_v_nnewdelconss, int __pyx_v_nnewaddconss, int __pyx_v_nnewupgdconss, int __pyx_v_nnewchgcoefs, int __pyx_v_nnewchgsides, int *__pyx_v_nfixedvars, int *__pyx_v_naggrvars, int *__pyx_v_nchgvartypes, int *__pyx_v_nchgbds, int *__pyx_v_naddholes, int *__pyx_v_ndelconss, int *__pyx_v_naddconss, int *__pyx_v_nupgdconss, int *__pyx_v_nchgcoefs, int *__pyx_v_nchgsides, SCIP_RESULT *__pyx_v_result) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + int __pyx_t_16; + SCIP_RESULT __pyx_t_17; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropPresol", 0); + + /* "src/pyscipopt/propagator.pxi":109 + * int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * # dictionary for input/output parameters + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":110 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * # dictionary for input/output parameters + * result_dict = {} + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":112 + * PyProp = propdata + * # dictionary for input/output parameters + * result_dict = {} # <<<<<<<<<<<<<< + * result_dict["nfixedvars"] = nfixedvars[0] + * result_dict["naggrvars"] = naggrvars[0] + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result_dict = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":113 + * # dictionary for input/output parameters + * result_dict = {} + * result_dict["nfixedvars"] = nfixedvars[0] # <<<<<<<<<<<<<< + * result_dict["naggrvars"] = naggrvars[0] + * result_dict["nchgvartypes"] = nchgvartypes[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nfixedvars[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nfixedvars, __pyx_t_1) < 0))) __PYX_ERR(15, 113, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":114 + * result_dict = {} + * result_dict["nfixedvars"] = nfixedvars[0] + * result_dict["naggrvars"] = naggrvars[0] # <<<<<<<<<<<<<< + * result_dict["nchgvartypes"] = nchgvartypes[0] + * result_dict["nchgbds"] = nchgbds[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_naggrvars[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_naggrvars, __pyx_t_1) < 0))) __PYX_ERR(15, 114, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":115 + * result_dict["nfixedvars"] = nfixedvars[0] + * result_dict["naggrvars"] = naggrvars[0] + * result_dict["nchgvartypes"] = nchgvartypes[0] # <<<<<<<<<<<<<< + * result_dict["nchgbds"] = nchgbds[0] + * result_dict["naddholes"] = naddholes[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgvartypes[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nchgvartypes, __pyx_t_1) < 0))) __PYX_ERR(15, 115, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":116 + * result_dict["naggrvars"] = naggrvars[0] + * result_dict["nchgvartypes"] = nchgvartypes[0] + * result_dict["nchgbds"] = nchgbds[0] # <<<<<<<<<<<<<< + * result_dict["naddholes"] = naddholes[0] + * result_dict["ndelconss"] = ndelconss[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgbds[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nchgbds, __pyx_t_1) < 0))) __PYX_ERR(15, 116, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":117 + * result_dict["nchgvartypes"] = nchgvartypes[0] + * result_dict["nchgbds"] = nchgbds[0] + * result_dict["naddholes"] = naddholes[0] # <<<<<<<<<<<<<< + * result_dict["ndelconss"] = ndelconss[0] + * result_dict["naddconss"] = naddconss[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_naddholes[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_naddholes, __pyx_t_1) < 0))) __PYX_ERR(15, 117, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":118 + * result_dict["nchgbds"] = nchgbds[0] + * result_dict["naddholes"] = naddholes[0] + * result_dict["ndelconss"] = ndelconss[0] # <<<<<<<<<<<<<< + * result_dict["naddconss"] = naddconss[0] + * result_dict["nupgdconss"] = nupgdconss[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_ndelconss[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_ndelconss, __pyx_t_1) < 0))) __PYX_ERR(15, 118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":119 + * result_dict["naddholes"] = naddholes[0] + * result_dict["ndelconss"] = ndelconss[0] + * result_dict["naddconss"] = naddconss[0] # <<<<<<<<<<<<<< + * result_dict["nupgdconss"] = nupgdconss[0] + * result_dict["nchgcoefs"] = nchgcoefs[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_naddconss[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_naddconss, __pyx_t_1) < 0))) __PYX_ERR(15, 119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":120 + * result_dict["ndelconss"] = ndelconss[0] + * result_dict["naddconss"] = naddconss[0] + * result_dict["nupgdconss"] = nupgdconss[0] # <<<<<<<<<<<<<< + * result_dict["nchgcoefs"] = nchgcoefs[0] + * result_dict["nchgsides"] = nchgsides[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nupgdconss[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nupgdconss, __pyx_t_1) < 0))) __PYX_ERR(15, 120, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":121 + * result_dict["naddconss"] = naddconss[0] + * result_dict["nupgdconss"] = nupgdconss[0] + * result_dict["nchgcoefs"] = nchgcoefs[0] # <<<<<<<<<<<<<< + * result_dict["nchgsides"] = nchgsides[0] + * result_dict["result"] = result[0] + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgcoefs[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nchgcoefs, __pyx_t_1) < 0))) __PYX_ERR(15, 121, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":122 + * result_dict["nupgdconss"] = nupgdconss[0] + * result_dict["nchgcoefs"] = nchgcoefs[0] + * result_dict["nchgsides"] = nchgsides[0] # <<<<<<<<<<<<<< + * result_dict["result"] = result[0] + * PyProp.proppresol(nrounds, presoltiming, + */ + __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_nchgsides[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_nchgsides, __pyx_t_1) < 0))) __PYX_ERR(15, 122, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":123 + * result_dict["nchgcoefs"] = nchgcoefs[0] + * result_dict["nchgsides"] = nchgsides[0] + * result_dict["result"] = result[0] # <<<<<<<<<<<<<< + * PyProp.proppresol(nrounds, presoltiming, + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + */ + __pyx_t_1 = __Pyx_PyInt_From_SCIP_RESULT((__pyx_v_result[0])); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_result_dict, __pyx_n_u_result, __pyx_t_1) < 0))) __PYX_ERR(15, 123, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":124 + * result_dict["nchgsides"] = nchgsides[0] + * result_dict["result"] = result[0] + * PyProp.proppresol(nrounds, presoltiming, # <<<<<<<<<<<<<< + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_proppresol); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nrounds); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(__pyx_v_presoltiming); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "src/pyscipopt/propagator.pxi":125 + * result_dict["result"] = result[0] + * PyProp.proppresol(nrounds, presoltiming, + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, # <<<<<<<<<<<<<< + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + * result[0] = result_dict["result"] + */ + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_nnewfixedvars); if (unlikely(!__pyx_t_5)) __PYX_ERR(15, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nnewaggrvars); if (unlikely(!__pyx_t_6)) __PYX_ERR(15, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nnewchgvartypes); if (unlikely(!__pyx_t_7)) __PYX_ERR(15, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_nnewchgbds); if (unlikely(!__pyx_t_8)) __PYX_ERR(15, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_nnewholes); if (unlikely(!__pyx_t_9)) __PYX_ERR(15, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "src/pyscipopt/propagator.pxi":126 + * PyProp.proppresol(nrounds, presoltiming, + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) # <<<<<<<<<<<<<< + * result[0] = result_dict["result"] + * nfixedvars[0] = result_dict["nfixedvars"] + */ + __pyx_t_10 = __Pyx_PyInt_From_int(__pyx_v_nnewdelconss); if (unlikely(!__pyx_t_10)) __PYX_ERR(15, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_nnewaddconss); if (unlikely(!__pyx_t_11)) __PYX_ERR(15, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_nnewupgdconss); if (unlikely(!__pyx_t_12)) __PYX_ERR(15, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_nnewchgcoefs); if (unlikely(!__pyx_t_13)) __PYX_ERR(15, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = __Pyx_PyInt_From_int(__pyx_v_nnewchgsides); if (unlikely(!__pyx_t_14)) __PYX_ERR(15, 126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = NULL; + __pyx_t_16 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_16 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[14] = {__pyx_t_15, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_v_result_dict}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_16, 13+__pyx_t_16); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":127 + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + * result[0] = result_dict["result"] # <<<<<<<<<<<<<< + * nfixedvars[0] = result_dict["nfixedvars"] + * naggrvars[0] = result_dict["naggrvars"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_17 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_17 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(15, 127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_17; + + /* "src/pyscipopt/propagator.pxi":128 + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict) + * result[0] = result_dict["result"] + * nfixedvars[0] = result_dict["nfixedvars"] # <<<<<<<<<<<<<< + * naggrvars[0] = result_dict["naggrvars"] + * nchgvartypes[0] = result_dict["nchgvartypes"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nfixedvars); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nfixedvars[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":129 + * result[0] = result_dict["result"] + * nfixedvars[0] = result_dict["nfixedvars"] + * naggrvars[0] = result_dict["naggrvars"] # <<<<<<<<<<<<<< + * nchgvartypes[0] = result_dict["nchgvartypes"] + * nchgbds[0] = result_dict["nchgbds"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_naggrvars); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_naggrvars[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":130 + * nfixedvars[0] = result_dict["nfixedvars"] + * naggrvars[0] = result_dict["naggrvars"] + * nchgvartypes[0] = result_dict["nchgvartypes"] # <<<<<<<<<<<<<< + * nchgbds[0] = result_dict["nchgbds"] + * naddholes[0] = result_dict["naddholes"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nchgvartypes); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 130, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgvartypes[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":131 + * naggrvars[0] = result_dict["naggrvars"] + * nchgvartypes[0] = result_dict["nchgvartypes"] + * nchgbds[0] = result_dict["nchgbds"] # <<<<<<<<<<<<<< + * naddholes[0] = result_dict["naddholes"] + * ndelconss[0] = result_dict["ndelconss"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nchgbds); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgbds[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":132 + * nchgvartypes[0] = result_dict["nchgvartypes"] + * nchgbds[0] = result_dict["nchgbds"] + * naddholes[0] = result_dict["naddholes"] # <<<<<<<<<<<<<< + * ndelconss[0] = result_dict["ndelconss"] + * naddconss[0] = result_dict["naddconss"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_naddholes); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 132, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_naddholes[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":133 + * nchgbds[0] = result_dict["nchgbds"] + * naddholes[0] = result_dict["naddholes"] + * ndelconss[0] = result_dict["ndelconss"] # <<<<<<<<<<<<<< + * naddconss[0] = result_dict["naddconss"] + * nupgdconss[0] = result_dict["nupgdconss"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_ndelconss); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 133, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_ndelconss[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":134 + * naddholes[0] = result_dict["naddholes"] + * ndelconss[0] = result_dict["ndelconss"] + * naddconss[0] = result_dict["naddconss"] # <<<<<<<<<<<<<< + * nupgdconss[0] = result_dict["nupgdconss"] + * nchgcoefs[0] = result_dict["nchgcoefs"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_naddconss); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 134, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_naddconss[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":135 + * ndelconss[0] = result_dict["ndelconss"] + * naddconss[0] = result_dict["naddconss"] + * nupgdconss[0] = result_dict["nupgdconss"] # <<<<<<<<<<<<<< + * nchgcoefs[0] = result_dict["nchgcoefs"] + * nchgsides[0] = result_dict["nchgsides"] + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nupgdconss); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 135, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nupgdconss[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":136 + * naddconss[0] = result_dict["naddconss"] + * nupgdconss[0] = result_dict["nupgdconss"] + * nchgcoefs[0] = result_dict["nchgcoefs"] # <<<<<<<<<<<<<< + * nchgsides[0] = result_dict["nchgsides"] + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nchgcoefs); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgcoefs[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":137 + * nupgdconss[0] = result_dict["nupgdconss"] + * nchgcoefs[0] = result_dict["nchgcoefs"] + * nchgsides[0] = result_dict["nchgsides"] # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_result_dict, __pyx_n_u_nchgsides); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(15, 137, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_nchgsides[0]) = __pyx_t_16; + + /* "src/pyscipopt/propagator.pxi":138 + * nchgcoefs[0] = result_dict["nchgcoefs"] + * nchgsides[0] = result_dict["nchgsides"] + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropExec (SCIP* scip, SCIP_PROP* prop, SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":103 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropPresol (SCIP* scip, SCIP_PROP* prop, int nrounds, SCIP_PRESOLTIMING presoltiming, # <<<<<<<<<<<<<< + * int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, + * int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropPresol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":140 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropExec (SCIP* scip, SCIP_PROP* prop, SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropExec(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop, SCIP_PROPTIMING __pyx_v_proptiming, SCIP_RESULT *__pyx_v_result) { + SCIP_PROPDATA *__pyx_v_propdata; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + PyObject *__pyx_v_returnvalues = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + SCIP_RESULT __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropExec", 0); + + /* "src/pyscipopt/propagator.pxi":142 + * cdef SCIP_RETCODE PyPropExec (SCIP* scip, SCIP_PROP* prop, SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * PyProp = propdata + * returnvalues = PyProp.propexec(proptiming) + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":143 + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + * PyProp = propdata # <<<<<<<<<<<<<< + * returnvalues = PyProp.propexec(proptiming) + * result_dict = returnvalues + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":144 + * propdata = SCIPpropGetData(prop) + * PyProp = propdata + * returnvalues = PyProp.propexec(proptiming) # <<<<<<<<<<<<<< + * result_dict = returnvalues + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propexec); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_PROPTIMING(__pyx_v_proptiming); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_returnvalues = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":145 + * PyProp = propdata + * returnvalues = PyProp.propexec(proptiming) + * result_dict = returnvalues # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __Pyx_INCREF(__pyx_v_returnvalues); + __pyx_v_result_dict = __pyx_v_returnvalues; + + /* "src/pyscipopt/propagator.pxi":146 + * returnvalues = PyProp.propexec(proptiming) + * result_dict = returnvalues + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_6 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_6 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(15, 146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_6; + + /* "src/pyscipopt/propagator.pxi":147 + * result_dict = returnvalues + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyPropResProp (SCIP* scip, SCIP_PROP* prop, SCIP_VAR* infervar, int inferinfo, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":140 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropExec (SCIP* scip, SCIP_PROP* prop, SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_PROPDATA* propdata + * propdata = SCIPpropGetData(prop) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropExec", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_XDECREF(__pyx_v_returnvalues); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/propagator.pxi":149 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropResProp (SCIP* scip, SCIP_PROP* prop, SCIP_VAR* infervar, int inferinfo, # <<<<<<<<<<<<<< + * SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyPropResProp(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_PROP *__pyx_v_prop, SCIP_VAR *__pyx_v_infervar, int __pyx_v_inferinfo, SCIP_BOUNDTYPE __pyx_v_boundtype, CYTHON_UNUSED SCIP_BDCHGIDX *__pyx_v_bdchgidx, SCIP_Real __pyx_v_relaxedbd, SCIP_RESULT *__pyx_v_result) { + SCIP_PROPDATA *__pyx_v_propdata; + SCIP_VAR *__pyx_v_tmp; + PyObject *__pyx_v_confvar = NULL; + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_PyProp = NULL; + PyObject *__pyx_v_returnvalues = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + SCIP_RESULT __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyPropResProp", 0); + + /* "src/pyscipopt/propagator.pxi":153 + * cdef SCIP_PROPDATA* propdata + * cdef SCIP_VAR* tmp + * tmp = infervar # <<<<<<<<<<<<<< + * propdata = SCIPpropGetData(prop) + * confvar = Variable.create(tmp) + */ + __pyx_v_tmp = __pyx_v_infervar; + + /* "src/pyscipopt/propagator.pxi":154 + * cdef SCIP_VAR* tmp + * tmp = infervar + * propdata = SCIPpropGetData(prop) # <<<<<<<<<<<<<< + * confvar = Variable.create(tmp) + * + */ + __pyx_v_propdata = SCIPpropGetData(__pyx_v_prop); + + /* "src/pyscipopt/propagator.pxi":155 + * tmp = infervar + * propdata = SCIPpropGetData(prop) + * confvar = Variable.create(tmp) # <<<<<<<<<<<<<< + * + * #TODO: parse bdchgidx? + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v_tmp); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_confvar = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":159 + * #TODO: parse bdchgidx? + * + * PyProp = propdata # <<<<<<<<<<<<<< + * returnvalues = PyProp.propresprop(confvar, inferinfo, boundtype, relaxedbd) + * result_dict = returnvalues + */ + __pyx_t_1 = ((PyObject *)__pyx_v_propdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyProp = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":160 + * + * PyProp = propdata + * returnvalues = PyProp.propresprop(confvar, inferinfo, boundtype, relaxedbd) # <<<<<<<<<<<<<< + * result_dict = returnvalues + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyProp), __pyx_n_s_propresprop); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_inferinfo); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_BOUNDTYPE(__pyx_v_boundtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_relaxedbd); if (unlikely(!__pyx_t_5)) __PYX_ERR(15, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_6, __pyx_v_confvar, __pyx_t_3, __pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 4+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_returnvalues = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/propagator.pxi":161 + * PyProp = propdata + * returnvalues = PyProp.propresprop(confvar, inferinfo, boundtype, relaxedbd) + * result_dict = returnvalues # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __Pyx_INCREF(__pyx_v_returnvalues); + __pyx_v_result_dict = __pyx_v_returnvalues; + + /* "src/pyscipopt/propagator.pxi":162 + * returnvalues = PyProp.propresprop(confvar, inferinfo, boundtype, relaxedbd) + * result_dict = returnvalues + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_5)) __PYX_ERR(15, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_n_u_result, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_8 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_8 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(15, 162, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_8; + + /* "src/pyscipopt/propagator.pxi":163 + * result_dict = returnvalues + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/propagator.pxi":149 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyPropResProp (SCIP* scip, SCIP_PROP* prop, SCIP_VAR* infervar, int inferinfo, # <<<<<<<<<<<<<< + * SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_PROPDATA* propdata + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pyscipopt.scip.PyPropResProp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_confvar); + __Pyx_XDECREF((PyObject *)__pyx_v_PyProp); + __Pyx_XDECREF(__pyx_v_returnvalues); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":7 + * cdef public str name + * + * def sepafree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of separator''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_1sepafree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_sepafree, "Sepa.sepafree(self)\ncalls destructor and frees memory of separator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_1sepafree = {"sepafree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_1sepafree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_sepafree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_1sepafree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepafree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("sepafree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sepafree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_sepafree(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_sepafree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepafree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":11 + * pass + * + * def sepainit(self): # <<<<<<<<<<<<<< + * '''initializes separator''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_3sepainit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_2sepainit, "Sepa.sepainit(self)\ninitializes separator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_3sepainit = {"sepainit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_3sepainit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_2sepainit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_3sepainit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepainit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("sepainit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sepainit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_2sepainit(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_2sepainit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepainit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":15 + * pass + * + * def sepaexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of separator''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_5sepaexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_4sepaexit, "Sepa.sepaexit(self)\ncalls exit method of separator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_5sepaexit = {"sepaexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_5sepaexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_4sepaexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_5sepaexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepaexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("sepaexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sepaexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_4sepaexit(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_4sepaexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepaexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":19 + * pass + * + * def sepainitsol(self): # <<<<<<<<<<<<<< + * '''informs separator that the branch and bound process is being started''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_7sepainitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_6sepainitsol, "Sepa.sepainitsol(self)\ninforms separator that the branch and bound process is being started"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_7sepainitsol = {"sepainitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_7sepainitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_6sepainitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_7sepainitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepainitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("sepainitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sepainitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_6sepainitsol(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_6sepainitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepainitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":23 + * pass + * + * def sepaexitsol(self): # <<<<<<<<<<<<<< + * '''informs separator that the branch and bound process data is being freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_9sepaexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_8sepaexitsol, "Sepa.sepaexitsol(self)\ninforms separator that the branch and bound process data is being freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_9sepaexitsol = {"sepaexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_9sepaexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_8sepaexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_9sepaexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepaexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("sepaexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sepaexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_8sepaexitsol(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_8sepaexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepaexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":27 + * pass + * + * def sepaexeclp(self): # <<<<<<<<<<<<<< + * '''calls LP separation method of separator''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_11sepaexeclp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_10sepaexeclp, "Sepa.sepaexeclp(self)\ncalls LP separation method of separator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_11sepaexeclp = {"sepaexeclp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_11sepaexeclp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_10sepaexeclp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_11sepaexeclp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepaexeclp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("sepaexeclp", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "sepaexeclp", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_10sepaexeclp(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_10sepaexeclp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("sepaexeclp", 1); + + /* "src/pyscipopt/sepa.pxi":29 + * def sepaexeclp(self): + * '''calls LP separation method of separator''' + * return {} # <<<<<<<<<<<<<< + * + * def sepaexecsol(self, solution): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":27 + * pass + * + * def sepaexeclp(self): # <<<<<<<<<<<<<< + * '''calls LP separation method of separator''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Sepa.sepaexeclp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":31 + * return {} + * + * def sepaexecsol(self, solution): # <<<<<<<<<<<<<< + * '''calls primal solution separation method of separator''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_13sepaexecsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_12sepaexecsol, "Sepa.sepaexecsol(self, solution)\ncalls primal solution separation method of separator"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_13sepaexecsol = {"sepaexecsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_13sepaexecsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_12sepaexecsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_13sepaexecsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_solution = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("sepaexecsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(16, 31, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "sepaexecsol") < 0)) __PYX_ERR(16, 31, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_solution = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("sepaexecsol", 1, 1, 1, __pyx_nargs); __PYX_ERR(16, 31, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Sepa.sepaexecsol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_12sepaexecsol(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self), __pyx_v_solution); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_12sepaexecsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_solution) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("sepaexecsol", 1); + + /* "src/pyscipopt/sepa.pxi":33 + * def sepaexecsol(self, solution): + * '''calls primal solution separation method of separator''' + * return {} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":31 + * return {} + * + * def sepaexecsol(self, solution): # <<<<<<<<<<<<<< + * '''calls primal solution separation method of separator''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Sepa.sepaexecsol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":4 + * #@brief Base class of the Separator Plugin + * cdef class Sepa: + * cdef public Model model # <<<<<<<<<<<<<< + * cdef public str name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Sepa_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Sepa_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Sepa_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(16, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Sepa.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Sepa_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Sepa_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Sepa_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":5 + * cdef class Sepa: + * cdef public Model model + * cdef public str name # <<<<<<<<<<<<<< + * + * def sepafree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Sepa_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Sepa_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_4name_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Sepa_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(PyUnicode_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_value))) __PYX_ERR(16, 5, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Sepa.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Sepa_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Sepa_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_4name_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Sepa_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_14__reduce_cython__, "Sepa.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_14__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_14__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_14__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model, self.name) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->name)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None or self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None or self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, None), state + */ + /*else*/ { + __pyx_t_4 = (((PyObject *)__pyx_v_self->model) != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->name != ((PyObject*)Py_None)); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Sepa); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, None), state + * else: + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Sepa__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Sepa); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Sepa.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Sepa__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Sepa_16__setstate_cython__, "Sepa.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Sepa_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_16__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Sepa_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Sepa.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Sepa_16__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Sepa_16__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Sepa__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Sepa__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Sepa__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Sepa.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":37 + * + * + * cdef SCIP_RETCODE PySepaCopy (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_SEPA *__pyx_v_sepa) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/sepa.pxi":38 + * + * cdef SCIP_RETCODE PySepaCopy (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PySepaFree (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":37 + * + * + * cdef SCIP_RETCODE PySepaCopy (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":40 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaFree (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_SEPA *__pyx_v_sepa) { + SCIP_SEPADATA *__pyx_v_sepadata; + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_PySepa = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PySepaFree", 0); + + /* "src/pyscipopt/sepa.pxi":42 + * cdef SCIP_RETCODE PySepaFree (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) # <<<<<<<<<<<<<< + * PySepa = sepadata + * PySepa.sepafree() + */ + __pyx_v_sepadata = SCIPsepaGetData(__pyx_v_sepa); + + /* "src/pyscipopt/sepa.pxi":43 + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata # <<<<<<<<<<<<<< + * PySepa.sepafree() + * Py_DECREF(PySepa) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_sepadata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PySepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":44 + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata + * PySepa.sepafree() # <<<<<<<<<<<<<< + * Py_DECREF(PySepa) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySepa), __pyx_n_s_sepafree); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":45 + * PySepa = sepadata + * PySepa.sepafree() + * Py_DECREF(PySepa) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PySepa)); + + /* "src/pyscipopt/sepa.pxi":46 + * PySepa.sepafree() + * Py_DECREF(PySepa) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PySepaInit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":40 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaFree (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PySepaFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PySepa); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":48 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaInit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_SEPA *__pyx_v_sepa) { + SCIP_SEPADATA *__pyx_v_sepadata; + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_PySepa = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PySepaInit", 0); + + /* "src/pyscipopt/sepa.pxi":50 + * cdef SCIP_RETCODE PySepaInit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) # <<<<<<<<<<<<<< + * PySepa = sepadata + * PySepa.sepainit() + */ + __pyx_v_sepadata = SCIPsepaGetData(__pyx_v_sepa); + + /* "src/pyscipopt/sepa.pxi":51 + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata # <<<<<<<<<<<<<< + * PySepa.sepainit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_sepadata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PySepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":52 + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata + * PySepa.sepainit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySepa), __pyx_n_s_sepainit); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":53 + * PySepa = sepadata + * PySepa.sepainit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PySepaExit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":48 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaInit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PySepaInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PySepa); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":55 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaExit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_SEPA *__pyx_v_sepa) { + SCIP_SEPADATA *__pyx_v_sepadata; + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_PySepa = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PySepaExit", 0); + + /* "src/pyscipopt/sepa.pxi":57 + * cdef SCIP_RETCODE PySepaExit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) # <<<<<<<<<<<<<< + * PySepa = sepadata + * PySepa.sepaexit() + */ + __pyx_v_sepadata = SCIPsepaGetData(__pyx_v_sepa); + + /* "src/pyscipopt/sepa.pxi":58 + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata # <<<<<<<<<<<<<< + * PySepa.sepaexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_sepadata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PySepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":59 + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata + * PySepa.sepaexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySepa), __pyx_n_s_sepaexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":60 + * PySepa = sepadata + * PySepa.sepaexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PySepaInitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":55 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaExit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PySepaExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PySepa); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":62 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaInitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_SEPA *__pyx_v_sepa) { + SCIP_SEPADATA *__pyx_v_sepadata; + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_PySepa = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PySepaInitsol", 0); + + /* "src/pyscipopt/sepa.pxi":64 + * cdef SCIP_RETCODE PySepaInitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) # <<<<<<<<<<<<<< + * PySepa = sepadata + * PySepa.sepainitsol() + */ + __pyx_v_sepadata = SCIPsepaGetData(__pyx_v_sepa); + + /* "src/pyscipopt/sepa.pxi":65 + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata # <<<<<<<<<<<<<< + * PySepa.sepainitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_sepadata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PySepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":66 + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata + * PySepa.sepainitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySepa), __pyx_n_s_sepainitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":67 + * PySepa = sepadata + * PySepa.sepainitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PySepaExitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":62 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaInitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PySepaInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PySepa); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":69 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaExitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_SEPA *__pyx_v_sepa) { + SCIP_SEPADATA *__pyx_v_sepadata; + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_PySepa = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PySepaExitsol", 0); + + /* "src/pyscipopt/sepa.pxi":71 + * cdef SCIP_RETCODE PySepaExitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) # <<<<<<<<<<<<<< + * PySepa = sepadata + * PySepa.sepaexitsol() + */ + __pyx_v_sepadata = SCIPsepaGetData(__pyx_v_sepa); + + /* "src/pyscipopt/sepa.pxi":72 + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata # <<<<<<<<<<<<<< + * PySepa.sepaexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_sepadata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PySepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":73 + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata + * PySepa.sepaexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySepa), __pyx_n_s_sepaexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":74 + * PySepa = sepadata + * PySepa.sepaexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PySepaExeclp (SCIP* scip, SCIP_SEPA* sepa, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":69 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaExitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PySepaExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PySepa); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":76 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaExeclp (SCIP* scip, SCIP_SEPA* sepa, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaExeclp(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_SEPA *__pyx_v_sepa, SCIP_RESULT *__pyx_v_result, CYTHON_UNUSED unsigned int __pyx_v_allowlocal, CYTHON_UNUSED int __pyx_v_depth) { + SCIP_SEPADATA *__pyx_v_sepadata; + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_PySepa = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + SCIP_RESULT __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PySepaExeclp", 0); + + /* "src/pyscipopt/sepa.pxi":78 + * cdef SCIP_RETCODE PySepaExeclp (SCIP* scip, SCIP_SEPA* sepa, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil: + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) # <<<<<<<<<<<<<< + * PySepa = sepadata + * result_dict = PySepa.sepaexeclp() + */ + __pyx_v_sepadata = SCIPsepaGetData(__pyx_v_sepa); + + /* "src/pyscipopt/sepa.pxi":79 + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata # <<<<<<<<<<<<<< + * result_dict = PySepa.sepaexeclp() + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_sepadata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PySepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":80 + * sepadata = SCIPsepaGetData(sepa) + * PySepa = sepadata + * result_dict = PySepa.sepaexeclp() # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySepa), __pyx_n_s_sepaexeclp); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":81 + * PySepa = sepadata + * result_dict = PySepa.sepaexeclp() + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_n_u_result, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 81, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_6 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_6 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(16, 81, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_6; + + /* "src/pyscipopt/sepa.pxi":82 + * result_dict = PySepa.sepaexeclp() + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PySepaExecsol (SCIP* scip, SCIP_SEPA* sepa, SCIP_SOL* sol, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":76 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaExeclp (SCIP* scip, SCIP_SEPA* sepa, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pyscipopt.scip.PySepaExeclp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PySepa); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/sepa.pxi":84 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaExecsol (SCIP* scip, SCIP_SEPA* sepa, SCIP_SOL* sol, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PySepaExecsol(SCIP *__pyx_v_scip, SCIP_SEPA *__pyx_v_sepa, SCIP_SOL *__pyx_v_sol, SCIP_RESULT *__pyx_v_result, CYTHON_UNUSED unsigned int __pyx_v_allowlocal, CYTHON_UNUSED int __pyx_v_depth) { + SCIP_SEPADATA *__pyx_v_sepadata; + PyObject *__pyx_v_solution = NULL; + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_PySepa = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + SCIP_RESULT __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PySepaExecsol", 0); + + /* "src/pyscipopt/sepa.pxi":86 + * cdef SCIP_RETCODE PySepaExecsol (SCIP* scip, SCIP_SEPA* sepa, SCIP_SOL* sol, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil: + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) # <<<<<<<<<<<<<< + * solution = Solution.create(scip, sol) + * PySepa = sepadata + */ + __pyx_v_sepadata = SCIPsepaGetData(__pyx_v_sepa); + + /* "src/pyscipopt/sepa.pxi":87 + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + * solution = Solution.create(scip, sol) # <<<<<<<<<<<<<< + * PySepa = sepadata + * result_dict = PySepa.sepaexecsol(solution) + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, __pyx_v_sol); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_solution = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":88 + * sepadata = SCIPsepaGetData(sepa) + * solution = Solution.create(scip, sol) + * PySepa = sepadata # <<<<<<<<<<<<<< + * result_dict = PySepa.sepaexecsol(solution) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_sepadata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PySepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":89 + * solution = Solution.create(scip, sol) + * PySepa = sepadata + * result_dict = PySepa.sepaexecsol(solution) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PySepa), __pyx_n_s_sepaexecsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_solution}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/sepa.pxi":90 + * PySepa = sepadata + * result_dict = PySepa.sepaexecsol(solution) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_n_u_result, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_6 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_6 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(16, 90, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_6; + + /* "src/pyscipopt/sepa.pxi":91 + * result_dict = PySepa.sepaexecsol(solution) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/sepa.pxi":84 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PySepaExecsol (SCIP* scip, SCIP_SEPA* sepa, SCIP_SOL* sol, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_SEPADATA* sepadata + * sepadata = SCIPsepaGetData(sepa) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pyscipopt.scip.PySepaExecsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XDECREF((PyObject *)__pyx_v_PySepa); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":7 + * cdef public str name + * + * def readerfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of reader''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_1readerfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Reader_readerfree, "Reader.readerfree(self)\ncalls destructor and frees memory of reader"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Reader_1readerfree = {"readerfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_1readerfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_readerfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_1readerfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readerfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("readerfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "readerfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_readerfree(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_readerfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readerfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":11 + * pass + * + * def readerread(self, filename): # <<<<<<<<<<<<<< + * '''calls read method of reader''' + * return {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_3readerread(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Reader_2readerread, "Reader.readerread(self, filename)\ncalls read method of reader"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Reader_3readerread = {"readerread", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_3readerread, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_2readerread}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_3readerread(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_filename = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readerread (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 11, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readerread") < 0)) __PYX_ERR(17, 11, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_filename = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("readerread", 1, 1, 1, __pyx_nargs); __PYX_ERR(17, 11, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Reader.readerread", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_2readerread(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self), __pyx_v_filename); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_2readerread(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_filename) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("readerread", 1); + + /* "src/pyscipopt/reader.pxi":13 + * def readerread(self, filename): + * '''calls read method of reader''' + * return {} # <<<<<<<<<<<<<< + * + * def readerwrite(self, file, name, transformed, objsense, objscale, objoffset, binvars, intvars, + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/reader.pxi":11 + * pass + * + * def readerread(self, filename): # <<<<<<<<<<<<<< + * '''calls read method of reader''' + * return {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Reader.readerread", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":15 + * return {} + * + * def readerwrite(self, file, name, transformed, objsense, objscale, objoffset, binvars, intvars, # <<<<<<<<<<<<<< + * implvars, contvars, fixedvars, startnvars, conss, maxnconss, startnconss, genericnames): + * '''calls write method of reader''' + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_5readerwrite(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Reader_4readerwrite, "Reader.readerwrite(self, file, name, transformed, objsense, objscale, objoffset, binvars, intvars, implvars, contvars, fixedvars, startnvars, conss, maxnconss, startnconss, genericnames)\ncalls write method of reader"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Reader_5readerwrite = {"readerwrite", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_5readerwrite, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_4readerwrite}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_5readerwrite(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_file = 0; + CYTHON_UNUSED PyObject *__pyx_v_name = 0; + CYTHON_UNUSED PyObject *__pyx_v_transformed = 0; + CYTHON_UNUSED PyObject *__pyx_v_objsense = 0; + CYTHON_UNUSED PyObject *__pyx_v_objscale = 0; + CYTHON_UNUSED PyObject *__pyx_v_objoffset = 0; + CYTHON_UNUSED PyObject *__pyx_v_binvars = 0; + CYTHON_UNUSED PyObject *__pyx_v_intvars = 0; + CYTHON_UNUSED PyObject *__pyx_v_implvars = 0; + CYTHON_UNUSED PyObject *__pyx_v_contvars = 0; + CYTHON_UNUSED PyObject *__pyx_v_fixedvars = 0; + CYTHON_UNUSED PyObject *__pyx_v_startnvars = 0; + CYTHON_UNUSED PyObject *__pyx_v_conss = 0; + CYTHON_UNUSED PyObject *__pyx_v_maxnconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_startnconss = 0; + CYTHON_UNUSED PyObject *__pyx_v_genericnames = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readerwrite (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_file,&__pyx_n_s_name,&__pyx_n_s_transformed,&__pyx_n_s_objsense,&__pyx_n_s_objscale,&__pyx_n_s_objoffset,&__pyx_n_s_binvars,&__pyx_n_s_intvars,&__pyx_n_s_implvars,&__pyx_n_s_contvars,&__pyx_n_s_fixedvars,&__pyx_n_s_startnvars,&__pyx_n_s_conss,&__pyx_n_s_maxnconss,&__pyx_n_s_startnconss,&__pyx_n_s_genericnames,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 16: values[15] = __Pyx_Arg_FASTCALL(__pyx_args, 15); + CYTHON_FALLTHROUGH; + case 15: values[14] = __Pyx_Arg_FASTCALL(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_file)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 1); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_transformed)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 2); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_objsense)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 3); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_objscale)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 4); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_objoffset)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[5]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 5); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (likely((values[6] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[6]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 6); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (likely((values[7] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_intvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[7]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 7); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (likely((values[8] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_implvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[8]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 8); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (likely((values[9] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_contvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[9]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 9); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (likely((values[10] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fixedvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[10]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 10); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (likely((values[11] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_startnvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[11]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 11); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 12: + if (likely((values[12] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_conss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[12]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 12); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 13: + if (likely((values[13] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxnconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[13]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 13); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 14: + if (likely((values[14] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_startnconss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[14]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 14); __PYX_ERR(17, 15, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 15: + if (likely((values[15] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_genericnames)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[15]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(17, 15, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, 15); __PYX_ERR(17, 15, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readerwrite") < 0)) __PYX_ERR(17, 15, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 16)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); + values[14] = __Pyx_Arg_FASTCALL(__pyx_args, 14); + values[15] = __Pyx_Arg_FASTCALL(__pyx_args, 15); + } + __pyx_v_file = values[0]; + __pyx_v_name = values[1]; + __pyx_v_transformed = values[2]; + __pyx_v_objsense = values[3]; + __pyx_v_objscale = values[4]; + __pyx_v_objoffset = values[5]; + __pyx_v_binvars = values[6]; + __pyx_v_intvars = values[7]; + __pyx_v_implvars = values[8]; + __pyx_v_contvars = values[9]; + __pyx_v_fixedvars = values[10]; + __pyx_v_startnvars = values[11]; + __pyx_v_conss = values[12]; + __pyx_v_maxnconss = values[13]; + __pyx_v_startnconss = values[14]; + __pyx_v_genericnames = values[15]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("readerwrite", 1, 16, 16, __pyx_nargs); __PYX_ERR(17, 15, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Reader.readerwrite", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_4readerwrite(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self), __pyx_v_file, __pyx_v_name, __pyx_v_transformed, __pyx_v_objsense, __pyx_v_objscale, __pyx_v_objoffset, __pyx_v_binvars, __pyx_v_intvars, __pyx_v_implvars, __pyx_v_contvars, __pyx_v_fixedvars, __pyx_v_startnvars, __pyx_v_conss, __pyx_v_maxnconss, __pyx_v_startnconss, __pyx_v_genericnames); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_4readerwrite(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_file, CYTHON_UNUSED PyObject *__pyx_v_name, CYTHON_UNUSED PyObject *__pyx_v_transformed, CYTHON_UNUSED PyObject *__pyx_v_objsense, CYTHON_UNUSED PyObject *__pyx_v_objscale, CYTHON_UNUSED PyObject *__pyx_v_objoffset, CYTHON_UNUSED PyObject *__pyx_v_binvars, CYTHON_UNUSED PyObject *__pyx_v_intvars, CYTHON_UNUSED PyObject *__pyx_v_implvars, CYTHON_UNUSED PyObject *__pyx_v_contvars, CYTHON_UNUSED PyObject *__pyx_v_fixedvars, CYTHON_UNUSED PyObject *__pyx_v_startnvars, CYTHON_UNUSED PyObject *__pyx_v_conss, CYTHON_UNUSED PyObject *__pyx_v_maxnconss, CYTHON_UNUSED PyObject *__pyx_v_startnconss, CYTHON_UNUSED PyObject *__pyx_v_genericnames) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("readerwrite", 1); + + /* "src/pyscipopt/reader.pxi":18 + * implvars, contvars, fixedvars, startnvars, conss, maxnconss, startnconss, genericnames): + * '''calls write method of reader''' + * return {} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/reader.pxi":15 + * return {} + * + * def readerwrite(self, file, name, transformed, objsense, objscale, objoffset, binvars, intvars, # <<<<<<<<<<<<<< + * implvars, contvars, fixedvars, startnvars, conss, maxnconss, startnconss, genericnames): + * '''calls write method of reader''' + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Reader.readerwrite", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":4 + * #@brief Base class of the Reader Plugin + * cdef class Reader: + * cdef public Model model # <<<<<<<<<<<<<< + * cdef public str name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Reader_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Reader_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Reader_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(17, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Reader.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Reader_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Reader_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Reader_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":5 + * cdef class Reader: + * cdef public Model model + * cdef public str name # <<<<<<<<<<<<<< + * + * def readerfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Reader_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Reader_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_4name_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Reader_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(PyUnicode_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_value))) __PYX_ERR(17, 5, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Reader.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Reader_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Reader_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_4name_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Reader_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Reader_6__reduce_cython__, "Reader.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Reader_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_6__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_6__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_6__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model, self.name) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->name)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None or self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None or self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, None), state + */ + /*else*/ { + __pyx_t_4 = (((PyObject *)__pyx_v_self->model) != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->name != ((PyObject*)Py_None)); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Reader); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, None), state + * else: + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Reader__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Reader); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Reader.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Reader__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Reader_8__setstate_cython__, "Reader.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Reader_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_8__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Reader_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Reader.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Reader_8__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Reader_8__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Reader__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Reader__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Reader__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Reader.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":21 + * + * + * cdef SCIP_RETCODE PyReaderCopy (SCIP* scip, SCIP_READER* reader) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyReaderCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_READER *__pyx_v_reader) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/reader.pxi":22 + * + * cdef SCIP_RETCODE PyReaderCopy (SCIP* scip, SCIP_READER* reader) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyReaderFree (SCIP* scip, SCIP_READER* reader) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/reader.pxi":21 + * + * + * cdef SCIP_RETCODE PyReaderCopy (SCIP* scip, SCIP_READER* reader) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":24 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyReaderFree (SCIP* scip, SCIP_READER* reader) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyReaderFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_READER *__pyx_v_reader) { + SCIP_READERDATA *__pyx_v_readerdata; + struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_PyReader = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyReaderFree", 0); + + /* "src/pyscipopt/reader.pxi":26 + * cdef SCIP_RETCODE PyReaderFree (SCIP* scip, SCIP_READER* reader) noexcept with gil: + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) # <<<<<<<<<<<<<< + * PyReader = readerdata + * PyReader.readerfree() + */ + __pyx_v_readerdata = SCIPreaderGetData(__pyx_v_reader); + + /* "src/pyscipopt/reader.pxi":27 + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) + * PyReader = readerdata # <<<<<<<<<<<<<< + * PyReader.readerfree() + * Py_DECREF(PyReader) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_readerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyReader = ((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/reader.pxi":28 + * readerdata = SCIPreaderGetData(reader) + * PyReader = readerdata + * PyReader.readerfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyReader) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyReader), __pyx_n_s_readerfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/reader.pxi":29 + * PyReader = readerdata + * PyReader.readerfree() + * Py_DECREF(PyReader) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyReader)); + + /* "src/pyscipopt/reader.pxi":30 + * PyReader.readerfree() + * Py_DECREF(PyReader) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyReaderRead (SCIP* scip, SCIP_READER* reader, const char* filename, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/reader.pxi":24 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyReaderFree (SCIP* scip, SCIP_READER* reader) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyReaderFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyReader); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":32 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyReaderRead (SCIP* scip, SCIP_READER* reader, const char* filename, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyReaderRead(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_READER *__pyx_v_reader, char const *__pyx_v_filename, SCIP_RESULT *__pyx_v_result) { + SCIP_READERDATA *__pyx_v_readerdata; + struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_PyReader = NULL; + PyObject *__pyx_v_PyFilename = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + SCIP_RESULT __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyReaderRead", 0); + + /* "src/pyscipopt/reader.pxi":34 + * cdef SCIP_RETCODE PyReaderRead (SCIP* scip, SCIP_READER* reader, const char* filename, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) # <<<<<<<<<<<<<< + * PyReader = readerdata + * PyFilename = filename.decode('utf-8') + */ + __pyx_v_readerdata = SCIPreaderGetData(__pyx_v_reader); + + /* "src/pyscipopt/reader.pxi":35 + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) + * PyReader = readerdata # <<<<<<<<<<<<<< + * PyFilename = filename.decode('utf-8') + * result_dict = PyReader.readerread(PyFilename) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_readerdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyReader = ((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/reader.pxi":36 + * readerdata = SCIPreaderGetData(reader) + * PyReader = readerdata + * PyFilename = filename.decode('utf-8') # <<<<<<<<<<<<<< + * result_dict = PyReader.readerread(PyFilename) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_2 = __Pyx_ssize_strlen(__pyx_v_filename); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(17, 36, __pyx_L1_error) + __pyx_t_1 = __Pyx_decode_c_string(__pyx_v_filename, 0, __pyx_t_2, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyFilename = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/reader.pxi":37 + * PyReader = readerdata + * PyFilename = filename.decode('utf-8') + * result_dict = PyReader.readerread(PyFilename) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyReader), __pyx_n_s_readerread); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_PyFilename}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/reader.pxi":38 + * PyFilename = filename.decode('utf-8') + * result_dict = PyReader.readerread(PyFilename) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_n_u_result, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_7 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_7 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(17, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_7; + + /* "src/pyscipopt/reader.pxi":39 + * result_dict = PyReader.readerread(PyFilename) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyReaderWrite (SCIP* scip, SCIP_READER* reader, FILE* file, + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/reader.pxi":32 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyReaderRead (SCIP* scip, SCIP_READER* reader, const char* filename, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pyscipopt.scip.PyReaderRead", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyReader); + __Pyx_XDECREF(__pyx_v_PyFilename); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/reader.pxi":41 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyReaderWrite (SCIP* scip, SCIP_READER* reader, FILE* file, # <<<<<<<<<<<<<< + * const char* name, SCIP_PROBDATA* probdata, SCIP_Bool transformed, + * SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyReaderWrite(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_READER *__pyx_v_reader, FILE *__pyx_v_file, char const *__pyx_v_name, CYTHON_UNUSED SCIP_PROBDATA *__pyx_v_probdata, SCIP_Bool __pyx_v_transformed, SCIP_OBJSENSE __pyx_v_objsense, SCIP_Real __pyx_v_objscale, SCIP_Real __pyx_v_objoffset, SCIP_VAR **__pyx_v_vars, CYTHON_UNUSED int __pyx_v_nvars, int __pyx_v_nbinvars, int __pyx_v_nintvars, int __pyx_v_nimplvars, int __pyx_v_ncontvars, SCIP_VAR **__pyx_v_fixedvars, int __pyx_v_nfixedvars, int __pyx_v_startnvars, SCIP_CONS **__pyx_v_conss, int __pyx_v_nconss, int __pyx_v_maxnconss, int __pyx_v_startnconss, SCIP_Bool __pyx_v_genericnames, SCIP_RESULT *__pyx_v_result) { + SCIP_READERDATA *__pyx_v_readerdata; + int __pyx_v_fd; + PyObject *__pyx_v_PyFile = NULL; + PyObject *__pyx_v_PyName = NULL; + PyObject *__pyx_v_PyBinVars = NULL; + PyObject *__pyx_v_PyIntVars = NULL; + PyObject *__pyx_v_PyImplVars = NULL; + PyObject *__pyx_v_PyContVars = NULL; + PyObject *__pyx_v_PyFixedVars = NULL; + PyObject *__pyx_v_PyConss = NULL; + struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_PyReader = NULL; + PyObject *__pyx_v_result_dict = NULL; + int __pyx_9genexpr11__pyx_v_i; + int __pyx_9genexpr12__pyx_v_i; + int __pyx_9genexpr13__pyx_v_i; + int __pyx_9genexpr14__pyx_v_i; + int __pyx_9genexpr15__pyx_v_i; + int __pyx_9genexpr16__pyx_v_i; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + SCIP_RESULT __pyx_t_16; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyReaderWrite", 0); + + /* "src/pyscipopt/reader.pxi":49 + * SCIP_Bool genericnames, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) # <<<<<<<<<<<<<< + * cdef int fd = fileno(file) + * PyFile = os.fdopen(fd, "w", closefd=False) + */ + __pyx_v_readerdata = SCIPreaderGetData(__pyx_v_reader); + + /* "src/pyscipopt/reader.pxi":50 + * cdef SCIP_READERDATA* readerdata + * readerdata = SCIPreaderGetData(reader) + * cdef int fd = fileno(file) # <<<<<<<<<<<<<< + * PyFile = os.fdopen(fd, "w", closefd=False) + * PyName = name.decode('utf-8') + */ + __pyx_v_fd = fileno(__pyx_v_file); + + /* "src/pyscipopt/reader.pxi":51 + * readerdata = SCIPreaderGetData(reader) + * cdef int fd = fileno(file) + * PyFile = os.fdopen(fd, "w", closefd=False) # <<<<<<<<<<<<<< + * PyName = name.decode('utf-8') + * PyBinVars = [Variable.create(vars[i]) for i in range(nbinvars)] + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_fdopen); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(17, 51, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_u_w); + __Pyx_GIVEREF(__pyx_n_u_w); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_n_u_w)) __PYX_ERR(17, 51, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_closefd, Py_False) < 0) __PYX_ERR(17, 51, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_PyFile = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":52 + * cdef int fd = fileno(file) + * PyFile = os.fdopen(fd, "w", closefd=False) + * PyName = name.decode('utf-8') # <<<<<<<<<<<<<< + * PyBinVars = [Variable.create(vars[i]) for i in range(nbinvars)] + * PyIntVars = [Variable.create(vars[i]) for i in range(nbinvars, nintvars)] + */ + __pyx_t_5 = __Pyx_ssize_strlen(__pyx_v_name); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(17, 52, __pyx_L1_error) + __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_name, 0, __pyx_t_5, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_PyName = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":53 + * PyFile = os.fdopen(fd, "w", closefd=False) + * PyName = name.decode('utf-8') + * PyBinVars = [Variable.create(vars[i]) for i in range(nbinvars)] # <<<<<<<<<<<<<< + * PyIntVars = [Variable.create(vars[i]) for i in range(nbinvars, nintvars)] + * PyImplVars = [Variable.create(vars[i]) for i in range(nintvars, nimplvars)] + */ + { /* enter inner scope */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __pyx_v_nbinvars; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_9genexpr11__pyx_v_i = __pyx_t_8; + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_vars[__pyx_9genexpr11__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_1))) __PYX_ERR(17, 53, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + } /* exit inner scope */ + __pyx_v_PyBinVars = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":54 + * PyName = name.decode('utf-8') + * PyBinVars = [Variable.create(vars[i]) for i in range(nbinvars)] + * PyIntVars = [Variable.create(vars[i]) for i in range(nbinvars, nintvars)] # <<<<<<<<<<<<<< + * PyImplVars = [Variable.create(vars[i]) for i in range(nintvars, nimplvars)] + * PyContVars = [Variable.create(vars[i]) for i in range(nimplvars, ncontvars)] + */ + { /* enter inner scope */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __pyx_v_nintvars; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = __pyx_v_nbinvars; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_9genexpr12__pyx_v_i = __pyx_t_8; + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_vars[__pyx_9genexpr12__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_1))) __PYX_ERR(17, 54, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + } /* exit inner scope */ + __pyx_v_PyIntVars = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":55 + * PyBinVars = [Variable.create(vars[i]) for i in range(nbinvars)] + * PyIntVars = [Variable.create(vars[i]) for i in range(nbinvars, nintvars)] + * PyImplVars = [Variable.create(vars[i]) for i in range(nintvars, nimplvars)] # <<<<<<<<<<<<<< + * PyContVars = [Variable.create(vars[i]) for i in range(nimplvars, ncontvars)] + * PyFixedVars = [Variable.create(fixedvars[i]) for i in range(nfixedvars)] + */ + { /* enter inner scope */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __pyx_v_nimplvars; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = __pyx_v_nintvars; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_9genexpr13__pyx_v_i = __pyx_t_8; + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_vars[__pyx_9genexpr13__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_1))) __PYX_ERR(17, 55, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + } /* exit inner scope */ + __pyx_v_PyImplVars = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":56 + * PyIntVars = [Variable.create(vars[i]) for i in range(nbinvars, nintvars)] + * PyImplVars = [Variable.create(vars[i]) for i in range(nintvars, nimplvars)] + * PyContVars = [Variable.create(vars[i]) for i in range(nimplvars, ncontvars)] # <<<<<<<<<<<<<< + * PyFixedVars = [Variable.create(fixedvars[i]) for i in range(nfixedvars)] + * PyConss = [Constraint.create(conss[i]) for i in range(nconss)] + */ + { /* enter inner scope */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __pyx_v_ncontvars; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = __pyx_v_nimplvars; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_9genexpr14__pyx_v_i = __pyx_t_8; + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_vars[__pyx_9genexpr14__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_1))) __PYX_ERR(17, 56, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + } /* exit inner scope */ + __pyx_v_PyContVars = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":57 + * PyImplVars = [Variable.create(vars[i]) for i in range(nintvars, nimplvars)] + * PyContVars = [Variable.create(vars[i]) for i in range(nimplvars, ncontvars)] + * PyFixedVars = [Variable.create(fixedvars[i]) for i in range(nfixedvars)] # <<<<<<<<<<<<<< + * PyConss = [Constraint.create(conss[i]) for i in range(nconss)] + * PyReader = readerdata + */ + { /* enter inner scope */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __pyx_v_nfixedvars; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_9genexpr15__pyx_v_i = __pyx_t_8; + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_fixedvars[__pyx_9genexpr15__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_1))) __PYX_ERR(17, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + } /* exit inner scope */ + __pyx_v_PyFixedVars = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":58 + * PyContVars = [Variable.create(vars[i]) for i in range(nimplvars, ncontvars)] + * PyFixedVars = [Variable.create(fixedvars[i]) for i in range(nfixedvars)] + * PyConss = [Constraint.create(conss[i]) for i in range(nconss)] # <<<<<<<<<<<<<< + * PyReader = readerdata + * result_dict = PyReader.readerwrite(PyFile, PyName, transformed, objsense, objscale, objoffset, + */ + { /* enter inner scope */ + __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __pyx_v_nconss; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_9genexpr16__pyx_v_i = __pyx_t_8; + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_10Constraint_create((__pyx_v_conss[__pyx_9genexpr16__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_1))) __PYX_ERR(17, 58, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + } /* exit inner scope */ + __pyx_v_PyConss = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":59 + * PyFixedVars = [Variable.create(fixedvars[i]) for i in range(nfixedvars)] + * PyConss = [Constraint.create(conss[i]) for i in range(nconss)] + * PyReader = readerdata # <<<<<<<<<<<<<< + * result_dict = PyReader.readerwrite(PyFile, PyName, transformed, objsense, objscale, objoffset, + * PyBinVars, PyIntVars, PyImplVars, PyContVars, PyFixedVars, startnvars, + */ + __pyx_t_4 = ((PyObject *)__pyx_v_readerdata); + __Pyx_INCREF(__pyx_t_4); + __pyx_v_PyReader = ((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":60 + * PyConss = [Constraint.create(conss[i]) for i in range(nconss)] + * PyReader = readerdata + * result_dict = PyReader.readerwrite(PyFile, PyName, transformed, objsense, objscale, objoffset, # <<<<<<<<<<<<<< + * PyBinVars, PyIntVars, PyImplVars, PyContVars, PyFixedVars, startnvars, + * PyConss, maxnconss, startnconss, genericnames) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyReader), __pyx_n_s_readerwrite); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_v_transformed); if (unlikely(!__pyx_t_3)) __PYX_ERR(17, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_From_SCIP_OBJSENSE(__pyx_v_objsense); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_objscale); if (unlikely(!__pyx_t_9)) __PYX_ERR(17, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = PyFloat_FromDouble(__pyx_v_objoffset); if (unlikely(!__pyx_t_10)) __PYX_ERR(17, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "src/pyscipopt/reader.pxi":61 + * PyReader = readerdata + * result_dict = PyReader.readerwrite(PyFile, PyName, transformed, objsense, objscale, objoffset, + * PyBinVars, PyIntVars, PyImplVars, PyContVars, PyFixedVars, startnvars, # <<<<<<<<<<<<<< + * PyConss, maxnconss, startnconss, genericnames) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_t_11 = __Pyx_PyInt_From_int(__pyx_v_startnvars); if (unlikely(!__pyx_t_11)) __PYX_ERR(17, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + + /* "src/pyscipopt/reader.pxi":62 + * result_dict = PyReader.readerwrite(PyFile, PyName, transformed, objsense, objscale, objoffset, + * PyBinVars, PyIntVars, PyImplVars, PyContVars, PyFixedVars, startnvars, + * PyConss, maxnconss, startnconss, genericnames) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_maxnconss); if (unlikely(!__pyx_t_12)) __PYX_ERR(17, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyInt_From_int(__pyx_v_startnconss); if (unlikely(!__pyx_t_13)) __PYX_ERR(17, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = __Pyx_PyBool_FromLong(__pyx_v_genericnames); if (unlikely(!__pyx_t_14)) __PYX_ERR(17, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_15)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_15); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[17] = {__pyx_t_15, __pyx_v_PyFile, __pyx_v_PyName, __pyx_t_3, __pyx_t_2, __pyx_t_9, __pyx_t_10, __pyx_v_PyBinVars, __pyx_v_PyIntVars, __pyx_v_PyImplVars, __pyx_v_PyContVars, __pyx_v_PyFixedVars, __pyx_t_11, __pyx_v_PyConss, __pyx_t_12, __pyx_t_13, __pyx_t_14}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 16+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_v_result_dict = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/reader.pxi":63 + * PyBinVars, PyIntVars, PyImplVars, PyContVars, PyFixedVars, startnvars, + * PyConss, maxnconss, startnconss, genericnames) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_14 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_14)) __PYX_ERR(17, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_13 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_13, __pyx_n_u_result, __pyx_t_14}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(17, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_16 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_4); if (unlikely((__pyx_t_16 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(17, 63, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + (__pyx_v_result[0]) = __pyx_t_16; + + /* "src/pyscipopt/reader.pxi":64 + * PyConss, maxnconss, startnconss, genericnames) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/reader.pxi":41 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyReaderWrite (SCIP* scip, SCIP_READER* reader, FILE* file, # <<<<<<<<<<<<<< + * const char* name, SCIP_PROBDATA* probdata, SCIP_Bool transformed, + * SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_WriteUnraisable("pyscipopt.scip.PyReaderWrite", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_PyFile); + __Pyx_XDECREF(__pyx_v_PyName); + __Pyx_XDECREF(__pyx_v_PyBinVars); + __Pyx_XDECREF(__pyx_v_PyIntVars); + __Pyx_XDECREF(__pyx_v_PyImplVars); + __Pyx_XDECREF(__pyx_v_PyContVars); + __Pyx_XDECREF(__pyx_v_PyFixedVars); + __Pyx_XDECREF(__pyx_v_PyConss); + __Pyx_XDECREF((PyObject *)__pyx_v_PyReader); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":7 + * cdef public str name + * + * def relaxfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of relaxation handler''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_1relaxfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Relax_relaxfree, "Relax.relaxfree(self)\ncalls destructor and frees memory of relaxation handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Relax_1relaxfree = {"relaxfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_1relaxfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_relaxfree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_1relaxfree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxfree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("relaxfree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "relaxfree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_relaxfree(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_relaxfree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxfree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":11 + * pass + * + * def relaxinit(self): # <<<<<<<<<<<<<< + * '''initializes relaxation handler''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_3relaxinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Relax_2relaxinit, "Relax.relaxinit(self)\ninitializes relaxation handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Relax_3relaxinit = {"relaxinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_3relaxinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_2relaxinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_3relaxinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("relaxinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "relaxinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_2relaxinit(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_2relaxinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":15 + * pass + * + * def relaxexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of relaxation handler''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_5relaxexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Relax_4relaxexit, "Relax.relaxexit(self)\ncalls exit method of relaxation handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Relax_5relaxexit = {"relaxexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_5relaxexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_4relaxexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_5relaxexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("relaxexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "relaxexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_4relaxexit(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_4relaxexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":19 + * pass + * + * def relaxinitsol(self): # <<<<<<<<<<<<<< + * '''informs relaxaton handler that the branch and bound process is being started''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_7relaxinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Relax_6relaxinitsol, "Relax.relaxinitsol(self)\ninforms relaxaton handler that the branch and bound process is being started"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Relax_7relaxinitsol = {"relaxinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_7relaxinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_6relaxinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_7relaxinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("relaxinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "relaxinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_6relaxinitsol(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_6relaxinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":23 + * pass + * + * def relaxexitsol(self): # <<<<<<<<<<<<<< + * '''informs relaxation handler that the branch and bound process data is being freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_9relaxexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Relax_8relaxexitsol, "Relax.relaxexitsol(self)\ninforms relaxation handler that the branch and bound process data is being freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Relax_9relaxexitsol = {"relaxexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_9relaxexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_8relaxexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_9relaxexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("relaxexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "relaxexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_8relaxexitsol(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_8relaxexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":27 + * pass + * + * def relaxexec(self): # <<<<<<<<<<<<<< + * '''callls execution method of relaxation handler''' + * print("python error in relaxexec: this method needs to be implemented") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_11relaxexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Relax_10relaxexec, "Relax.relaxexec(self)\ncallls execution method of relaxation handler"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Relax_11relaxexec = {"relaxexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_11relaxexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_10relaxexec}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_11relaxexec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relaxexec (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("relaxexec", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "relaxexec", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_10relaxexec(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_10relaxexec(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("relaxexec", 1); + + /* "src/pyscipopt/relax.pxi":29 + * def relaxexec(self): + * '''callls execution method of relaxation handler''' + * print("python error in relaxexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return{} + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":30 + * '''callls execution method of relaxation handler''' + * print("python error in relaxexec: this method needs to be implemented") + * return{} # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/relax.pxi":27 + * pass + * + * def relaxexec(self): # <<<<<<<<<<<<<< + * '''callls execution method of relaxation handler''' + * print("python error in relaxexec: this method needs to be implemented") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Relax.relaxexec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":4 + * #@brief Base class of the Relaxator Plugin + * cdef class Relax: + * cdef public Model model # <<<<<<<<<<<<<< + * cdef public str name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Relax_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Relax_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Relax_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(18, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Relax.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Relax_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Relax_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Relax_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":5 + * cdef class Relax: + * cdef public Model model + * cdef public str name # <<<<<<<<<<<<<< + * + * def relaxfree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Relax_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Relax_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_4name_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Relax_4name_2__set__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(PyUnicode_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_value))) __PYX_ERR(18, 5, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Relax.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Relax_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Relax_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_4name_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Relax_4name_4__del__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Relax_12__reduce_cython__, "Relax.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Relax_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_12__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_12__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_12__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model, self.name) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->name)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None or self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model, self.name) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None or self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, None), state + */ + /*else*/ { + __pyx_t_4 = (((PyObject *)__pyx_v_self->model) != Py_None); + if (!__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->name != ((PyObject*)Py_None)); + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Relax); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None or self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, None), state + * else: + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Relax__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Relax); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_76513566); + __Pyx_GIVEREF(__pyx_int_76513566); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_76513566)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Relax.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Relax__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Relax_14__setstate_cython__, "Relax.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Relax_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_14__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Relax_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Relax.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Relax_14__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Relax_14__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Relax__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Relax__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Relax__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Relax.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":33 + * + * + * cdef SCIP_RETCODE PyRelaxCopy (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_RELAX *__pyx_v_relax) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/relax.pxi":34 + * + * cdef SCIP_RETCODE PyRelaxCopy (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyRelaxFree (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/relax.pxi":33 + * + * + * cdef SCIP_RETCODE PyRelaxCopy (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":36 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxFree (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_RELAX *__pyx_v_relax) { + SCIP_RELAXDATA *__pyx_v_relaxdata; + struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_PyRelax = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyRelaxFree", 0); + + /* "src/pyscipopt/relax.pxi":38 + * cdef SCIP_RETCODE PyRelaxFree (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) # <<<<<<<<<<<<<< + * PyRelax = relaxdata + * PyRelax.relaxfree() + */ + __pyx_v_relaxdata = SCIPrelaxGetData(__pyx_v_relax); + + /* "src/pyscipopt/relax.pxi":39 + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata # <<<<<<<<<<<<<< + * PyRelax.relaxfree() + * Py_DECREF(PyRelax) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_relaxdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyRelax = ((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":40 + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata + * PyRelax.relaxfree() # <<<<<<<<<<<<<< + * Py_DECREF(PyRelax) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyRelax), __pyx_n_s_relaxfree); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":41 + * PyRelax = relaxdata + * PyRelax.relaxfree() + * Py_DECREF(PyRelax) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyRelax)); + + /* "src/pyscipopt/relax.pxi":42 + * PyRelax.relaxfree() + * Py_DECREF(PyRelax) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyRelaxInit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/relax.pxi":36 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxFree (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyRelaxFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyRelax); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":44 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxInit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_RELAX *__pyx_v_relax) { + SCIP_RELAXDATA *__pyx_v_relaxdata; + struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_PyRelax = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyRelaxInit", 0); + + /* "src/pyscipopt/relax.pxi":46 + * cdef SCIP_RETCODE PyRelaxInit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) # <<<<<<<<<<<<<< + * PyRelax = relaxdata + * PyRelax.relaxinit() + */ + __pyx_v_relaxdata = SCIPrelaxGetData(__pyx_v_relax); + + /* "src/pyscipopt/relax.pxi":47 + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata # <<<<<<<<<<<<<< + * PyRelax.relaxinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_relaxdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyRelax = ((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":48 + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata + * PyRelax.relaxinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyRelax), __pyx_n_s_relaxinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":49 + * PyRelax = relaxdata + * PyRelax.relaxinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyRelaxExit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/relax.pxi":44 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxInit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyRelaxInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyRelax); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":51 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxExit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_RELAX *__pyx_v_relax) { + SCIP_RELAXDATA *__pyx_v_relaxdata; + struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_PyRelax = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyRelaxExit", 0); + + /* "src/pyscipopt/relax.pxi":53 + * cdef SCIP_RETCODE PyRelaxExit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) # <<<<<<<<<<<<<< + * PyRelax = relaxdata + * PyRelax.relaxexit() + */ + __pyx_v_relaxdata = SCIPrelaxGetData(__pyx_v_relax); + + /* "src/pyscipopt/relax.pxi":54 + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata # <<<<<<<<<<<<<< + * PyRelax.relaxexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_relaxdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyRelax = ((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":55 + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata + * PyRelax.relaxexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyRelax), __pyx_n_s_relaxexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 55, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":56 + * PyRelax = relaxdata + * PyRelax.relaxexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyRelaxInitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/relax.pxi":51 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxExit (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyRelaxExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyRelax); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":58 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxInitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_RELAX *__pyx_v_relax) { + SCIP_RELAXDATA *__pyx_v_relaxdata; + struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_PyRelax = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyRelaxInitsol", 0); + + /* "src/pyscipopt/relax.pxi":60 + * cdef SCIP_RETCODE PyRelaxInitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) # <<<<<<<<<<<<<< + * PyRelax = relaxdata + * PyRelax.relaxinitsol() + */ + __pyx_v_relaxdata = SCIPrelaxGetData(__pyx_v_relax); + + /* "src/pyscipopt/relax.pxi":61 + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata # <<<<<<<<<<<<<< + * PyRelax.relaxinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_relaxdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyRelax = ((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":62 + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata + * PyRelax.relaxinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyRelax), __pyx_n_s_relaxinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":63 + * PyRelax = relaxdata + * PyRelax.relaxinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyRelaxExitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/relax.pxi":58 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxInitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyRelaxInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyRelax); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":65 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxExitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_RELAX *__pyx_v_relax) { + SCIP_RELAXDATA *__pyx_v_relaxdata; + struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_PyRelax = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyRelaxExitsol", 0); + + /* "src/pyscipopt/relax.pxi":67 + * cdef SCIP_RETCODE PyRelaxExitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) # <<<<<<<<<<<<<< + * PyRelax = relaxdata + * PyRelax.relaxexitsol() + */ + __pyx_v_relaxdata = SCIPrelaxGetData(__pyx_v_relax); + + /* "src/pyscipopt/relax.pxi":68 + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata # <<<<<<<<<<<<<< + * PyRelax.relaxexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_relaxdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyRelax = ((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":69 + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata + * PyRelax.relaxexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyRelax), __pyx_n_s_relaxexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 69, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":70 + * PyRelax = relaxdata + * PyRelax.relaxexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyRelaxExec (SCIP* scip, SCIP_RELAX* relax, SCIP_Real* lowerbound, SCIP_RESULT* result) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/relax.pxi":65 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxExitsol (SCIP* scip, SCIP_RELAX* relax) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyRelaxExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyRelax); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/relax.pxi":72 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxExec (SCIP* scip, SCIP_RELAX* relax, SCIP_Real* lowerbound, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyRelaxExec(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_RELAX *__pyx_v_relax, SCIP_Real *__pyx_v_lowerbound, SCIP_RESULT *__pyx_v_result) { + SCIP_RELAXDATA *__pyx_v_relaxdata; + struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_PyRelax = NULL; + PyObject *__pyx_v_result_dict = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + SCIP_Real __pyx_t_7; + SCIP_RESULT __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyRelaxExec", 0); + + /* "src/pyscipopt/relax.pxi":74 + * cdef SCIP_RETCODE PyRelaxExec (SCIP* scip, SCIP_RELAX* relax, SCIP_Real* lowerbound, SCIP_RESULT* result) noexcept with gil: + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) # <<<<<<<<<<<<<< + * PyRelax = relaxdata + * result_dict = PyRelax.relaxexec() + */ + __pyx_v_relaxdata = SCIPrelaxGetData(__pyx_v_relax); + + /* "src/pyscipopt/relax.pxi":75 + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata # <<<<<<<<<<<<<< + * result_dict = PyRelax.relaxexec() + * assert isinstance(result_dict, dict), "relaxexec() must return a dictionary." + */ + __pyx_t_1 = ((PyObject *)__pyx_v_relaxdata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyRelax = ((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":76 + * relaxdata = SCIPrelaxGetData(relax) + * PyRelax = relaxdata + * result_dict = PyRelax.relaxexec() # <<<<<<<<<<<<<< + * assert isinstance(result_dict, dict), "relaxexec() must return a dictionary." + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyRelax), __pyx_n_s_relaxexec); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/relax.pxi":77 + * PyRelax = relaxdata + * result_dict = PyRelax.relaxexec() + * assert isinstance(result_dict, dict), "relaxexec() must return a dictionary." # <<<<<<<<<<<<<< + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + * result[0] = result_dict.get("result", result[0]) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_5 = PyDict_Check(__pyx_v_result_dict); + if (unlikely(!__pyx_t_5)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_relaxexec_must_return_a_dictiona, 0, 0); + __PYX_ERR(18, 77, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(18, 77, __pyx_L1_error) + #endif + + /* "src/pyscipopt/relax.pxi":78 + * result_dict = PyRelax.relaxexec() + * assert isinstance(result_dict, dict), "relaxexec() must return a dictionary." + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyFloat_FromDouble(((SCIP_Real)(__pyx_v_lowerbound[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_n_u_lowerbound, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 78, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_7 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_7 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(18, 78, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_lowerbound[0]) = __pyx_t_7; + + /* "src/pyscipopt/relax.pxi":79 + * assert isinstance(result_dict, dict), "relaxexec() must return a dictionary." + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + * result[0] = result_dict.get("result", result[0]) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RESULT(((SCIP_RESULT)(__pyx_v_result[0]))); if (unlikely(!__pyx_t_3)) __PYX_ERR(18, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_n_u_result, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 79, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_8 = __Pyx_PyInt_As_SCIP_RESULT(__pyx_t_1); if (unlikely((__pyx_t_8 == ((SCIP_RESULT)-1)) && PyErr_Occurred())) __PYX_ERR(18, 79, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + (__pyx_v_result[0]) = __pyx_t_8; + + /* "src/pyscipopt/relax.pxi":80 + * lowerbound[0] = result_dict.get("lowerbound", lowerbound[0]) + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY # <<<<<<<<<<<<<< + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/relax.pxi":72 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyRelaxExec (SCIP* scip, SCIP_RELAX* relax, SCIP_Real* lowerbound, SCIP_RESULT* result) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_RELAXDATA* relaxdata + * relaxdata = SCIPrelaxGetData(relax) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pyscipopt.scip.PyRelaxExec", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyRelax); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":6 + * cdef public Model model + * + * def nodefree(self): # <<<<<<<<<<<<<< + * '''frees memory of node selector''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_1nodefree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_nodefree, "Nodesel.nodefree(self)\nfrees memory of node selector"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_1nodefree = {"nodefree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_1nodefree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_nodefree}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_1nodefree(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodefree (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("nodefree", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "nodefree", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_nodefree(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_nodefree(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodefree", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":10 + * pass + * + * def nodeinit(self): # <<<<<<<<<<<<<< + * ''' executed after the problem is transformed. use this call to initialize node selector data.''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_3nodeinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_2nodeinit, "Nodesel.nodeinit(self)\n executed after the problem is transformed. use this call to initialize node selector data."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_3nodeinit = {"nodeinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_3nodeinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_2nodeinit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_3nodeinit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeinit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("nodeinit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "nodeinit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_2nodeinit(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_2nodeinit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeinit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":14 + * pass + * + * def nodeexit(self): # <<<<<<<<<<<<<< + * '''executed before the transformed problem is freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_5nodeexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_4nodeexit, "Nodesel.nodeexit(self)\nexecuted before the transformed problem is freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_5nodeexit = {"nodeexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_5nodeexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_4nodeexit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_5nodeexit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeexit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("nodeexit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "nodeexit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_4nodeexit(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_4nodeexit(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeexit", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":18 + * pass + * + * def nodeinitsol(self): # <<<<<<<<<<<<<< + * '''executed when the presolving is finished and the branch-and-bound process is about to begin''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_7nodeinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_6nodeinitsol, "Nodesel.nodeinitsol(self)\nexecuted when the presolving is finished and the branch-and-bound process is about to begin"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_7nodeinitsol = {"nodeinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_7nodeinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_6nodeinitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_7nodeinitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeinitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("nodeinitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "nodeinitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_6nodeinitsol(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_6nodeinitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeinitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":22 + * pass + * + * def nodeexitsol(self): # <<<<<<<<<<<<<< + * '''executed before the branch-and-bound process is freed''' + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_9nodeexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_8nodeexitsol, "Nodesel.nodeexitsol(self)\nexecuted before the branch-and-bound process is freed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_9nodeexitsol = {"nodeexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_9nodeexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_8nodeexitsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_9nodeexitsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeexitsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("nodeexitsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "nodeexitsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_8nodeexitsol(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_8nodeexitsol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeexitsol", 1); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":26 + * pass + * + * def nodeselect(self): # <<<<<<<<<<<<<< + * '''first method called in each iteration in the main solving loop. ''' + * # this method needs to be implemented by the user + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_11nodeselect(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_10nodeselect, "Nodesel.nodeselect(self)\nfirst method called in each iteration in the main solving loop. "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_11nodeselect = {"nodeselect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_11nodeselect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_10nodeselect}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_11nodeselect(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodeselect (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("nodeselect", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "nodeselect", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_10nodeselect(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_10nodeselect(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("nodeselect", 1); + + /* "src/pyscipopt/nodesel.pxi":29 + * '''first method called in each iteration in the main solving loop. ''' + * # this method needs to be implemented by the user + * return {} # <<<<<<<<<<<<<< + * + * def nodecomp(self, node1, node2): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":26 + * pass + * + * def nodeselect(self): # <<<<<<<<<<<<<< + * '''first method called in each iteration in the main solving loop. ''' + * # this method needs to be implemented by the user + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Nodesel.nodeselect", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":31 + * return {} + * + * def nodecomp(self, node1, node2): # <<<<<<<<<<<<<< + * ''' + * compare two leaves of the current branching tree + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_13nodecomp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_12nodecomp, "Nodesel.nodecomp(self, node1, node2)\n\n compare two leaves of the current branching tree\n\n It should return the following values:\n\n value < 0, if node 1 comes before (is better than) node 2\n value = 0, if both nodes are equally good\n value > 0, if node 1 comes after (is worse than) node 2.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_13nodecomp = {"nodecomp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_13nodecomp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_12nodecomp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_13nodecomp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v_node1 = 0; + CYTHON_UNUSED PyObject *__pyx_v_node2 = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodecomp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_node1,&__pyx_n_s_node2,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_node1)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 31, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_node2)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 31, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("nodecomp", 1, 2, 2, 1); __PYX_ERR(19, 31, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "nodecomp") < 0)) __PYX_ERR(19, 31, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_node1 = values[0]; + __pyx_v_node2 = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("nodecomp", 1, 2, 2, __pyx_nargs); __PYX_ERR(19, 31, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Nodesel.nodecomp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_12nodecomp(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self), __pyx_v_node1, __pyx_v_node2); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_12nodecomp(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_node1, CYTHON_UNUSED PyObject *__pyx_v_node2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("nodecomp", 1); + + /* "src/pyscipopt/nodesel.pxi":42 + * ''' + * # this method needs to be implemented by the user + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_int_0); + __pyx_r = __pyx_int_0; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":31 + * return {} + * + * def nodecomp(self, node1, node2): # <<<<<<<<<<<<<< + * ''' + * compare two leaves of the current branching tree + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":4 + * #@brief Base class of the Nodesel Plugin + * cdef class Nodesel: + * cdef public Model model # <<<<<<<<<<<<<< + * + * def nodefree(self): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_5model_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_5model_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_5model___get__(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_5model___get__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __pyx_r = ((PyObject *)__pyx_v_self->model); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7Nodesel_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7Nodesel_5model_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_5model_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7Nodesel_5model_2__set__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 1); + if (!(likely(((__pyx_v_value) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_value, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(19, 4, __pyx_L1_error) + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Nodesel.model.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_7Nodesel_5model_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_7Nodesel_5model_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_5model_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_7Nodesel_5model_4__del__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->model); + __Pyx_DECREF((PyObject *)__pyx_v_self->model); + __pyx_v_self->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_14__reduce_cython__, "Nodesel.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_14__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_14__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_14__reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.model,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF((PyObject *)__pyx_v_self->model); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->model); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self->model))) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.model is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.model,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.model is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, None), state + */ + /*else*/ { + __pyx_t_2 = (((PyObject *)__pyx_v_self->model) != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.model is not None + * if use_setstate: + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_Nodesel); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.model is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, None), state + * else: + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Nodesel__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Nodesel); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_154610759); + __Pyx_GIVEREF(__pyx_int_154610759); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_154610759)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Nodesel.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Nodesel__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_7Nodesel_16__setstate_cython__, "Nodesel.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_7Nodesel_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_16__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_7Nodesel_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Nodesel.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_7Nodesel_16__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_7Nodesel_16__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Nodesel__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Nodesel__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Nodesel__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Nodesel.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":45 + * + * + * cdef SCIP_RETCODE PyNodeselCopy (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselCopy(CYTHON_UNUSED SCIP *__pyx_v_scip, CYTHON_UNUSED SCIP_NODESEL *__pyx_v_nodesel) { + SCIP_RETCODE __pyx_r; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + + /* "src/pyscipopt/nodesel.pxi":46 + * + * cdef SCIP_RETCODE PyNodeselCopy (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyNodeselFree (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":45 + * + * + * cdef SCIP_RETCODE PyNodeselCopy (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + + /* function exit code */ + __pyx_L0:; + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":48 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselFree (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselFree(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_NODESEL *__pyx_v_nodesel) { + SCIP_NODESELDATA *__pyx_v_nodeseldata; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_PyNodesel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyNodeselFree", 0); + + /* "src/pyscipopt/nodesel.pxi":50 + * cdef SCIP_RETCODE PyNodeselFree (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) # <<<<<<<<<<<<<< + * PyNodesel = nodeseldata + * PyNodesel.nodefree() + */ + __pyx_v_nodeseldata = SCIPnodeselGetData(__pyx_v_nodesel); + + /* "src/pyscipopt/nodesel.pxi":51 + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata # <<<<<<<<<<<<<< + * PyNodesel.nodefree() + * Py_DECREF(PyNodesel) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_nodeseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyNodesel = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":52 + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata + * PyNodesel.nodefree() # <<<<<<<<<<<<<< + * Py_DECREF(PyNodesel) + * return SCIP_OKAY + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyNodesel), __pyx_n_s_nodefree); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":53 + * PyNodesel = nodeseldata + * PyNodesel.nodefree() + * Py_DECREF(PyNodesel) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + Py_DECREF(((PyObject *)__pyx_v_PyNodesel)); + + /* "src/pyscipopt/nodesel.pxi":54 + * PyNodesel.nodefree() + * Py_DECREF(PyNodesel) + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyNodeselInit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":48 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselFree (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyNodeselFree", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyNodesel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":56 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselInit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselInit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_NODESEL *__pyx_v_nodesel) { + SCIP_NODESELDATA *__pyx_v_nodeseldata; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_PyNodesel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyNodeselInit", 0); + + /* "src/pyscipopt/nodesel.pxi":58 + * cdef SCIP_RETCODE PyNodeselInit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) # <<<<<<<<<<<<<< + * PyNodesel = nodeseldata + * PyNodesel.nodeinit() + */ + __pyx_v_nodeseldata = SCIPnodeselGetData(__pyx_v_nodesel); + + /* "src/pyscipopt/nodesel.pxi":59 + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata # <<<<<<<<<<<<<< + * PyNodesel.nodeinit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_nodeseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyNodesel = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":60 + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata + * PyNodesel.nodeinit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyNodesel), __pyx_n_s_nodeinit); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 60, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":61 + * PyNodesel = nodeseldata + * PyNodesel.nodeinit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":56 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselInit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyNodeselInit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyNodesel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":64 + * + * + * cdef SCIP_RETCODE PyNodeselExit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselExit(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_NODESEL *__pyx_v_nodesel) { + SCIP_NODESELDATA *__pyx_v_nodeseldata; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_PyNodesel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyNodeselExit", 0); + + /* "src/pyscipopt/nodesel.pxi":66 + * cdef SCIP_RETCODE PyNodeselExit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) # <<<<<<<<<<<<<< + * PyNodesel = nodeseldata + * PyNodesel.nodeexit() + */ + __pyx_v_nodeseldata = SCIPnodeselGetData(__pyx_v_nodesel); + + /* "src/pyscipopt/nodesel.pxi":67 + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata # <<<<<<<<<<<<<< + * PyNodesel.nodeexit() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_nodeseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyNodesel = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":68 + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata + * PyNodesel.nodeexit() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyNodesel), __pyx_n_s_nodeexit); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":69 + * PyNodesel = nodeseldata + * PyNodesel.nodeexit() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyNodeselInitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":64 + * + * + * cdef SCIP_RETCODE PyNodeselExit (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyNodeselExit", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyNodesel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":71 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselInitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselInitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_NODESEL *__pyx_v_nodesel) { + SCIP_NODESELDATA *__pyx_v_nodeseldata; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_PyNodesel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyNodeselInitsol", 0); + + /* "src/pyscipopt/nodesel.pxi":73 + * cdef SCIP_RETCODE PyNodeselInitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) # <<<<<<<<<<<<<< + * PyNodesel = nodeseldata + * PyNodesel.nodeinitsol() + */ + __pyx_v_nodeseldata = SCIPnodeselGetData(__pyx_v_nodesel); + + /* "src/pyscipopt/nodesel.pxi":74 + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata # <<<<<<<<<<<<<< + * PyNodesel.nodeinitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_nodeseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyNodesel = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":75 + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata + * PyNodesel.nodeinitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyNodesel), __pyx_n_s_nodeinitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 75, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":76 + * PyNodesel = nodeseldata + * PyNodesel.nodeinitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyNodeselExitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":71 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselInitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyNodeselInitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyNodesel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":78 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselExitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselExitsol(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_NODESEL *__pyx_v_nodesel) { + SCIP_NODESELDATA *__pyx_v_nodeseldata; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_PyNodesel = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyNodeselExitsol", 0); + + /* "src/pyscipopt/nodesel.pxi":80 + * cdef SCIP_RETCODE PyNodeselExitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) # <<<<<<<<<<<<<< + * PyNodesel = nodeseldata + * PyNodesel.nodeexitsol() + */ + __pyx_v_nodeseldata = SCIPnodeselGetData(__pyx_v_nodesel); + + /* "src/pyscipopt/nodesel.pxi":81 + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata # <<<<<<<<<<<<<< + * PyNodesel.nodeexitsol() + * return SCIP_OKAY + */ + __pyx_t_1 = ((PyObject *)__pyx_v_nodeseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyNodesel = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":82 + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata + * PyNodesel.nodeexitsol() # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyNodesel), __pyx_n_s_nodeexitsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 82, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":83 + * PyNodesel = nodeseldata + * PyNodesel.nodeexitsol() + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef SCIP_RETCODE PyNodeselSelect (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE** selnode) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":78 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselExitsol (SCIP* scip, SCIP_NODESEL* nodesel) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyNodeselExitsol", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyNodesel); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":85 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselSelect (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE** selnode) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + +static SCIP_RETCODE __pyx_f_9pyscipopt_4scip_PyNodeselSelect(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_NODESEL *__pyx_v_nodesel, SCIP_NODE **__pyx_v_selnode) { + SCIP_NODESELDATA *__pyx_v_nodeseldata; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_PyNodesel = NULL; + PyObject *__pyx_v_result_dict = NULL; + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_selected_node = NULL; + SCIP_RETCODE __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + SCIP_NODE *__pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyNodeselSelect", 0); + + /* "src/pyscipopt/nodesel.pxi":87 + * cdef SCIP_RETCODE PyNodeselSelect (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE** selnode) noexcept with gil: + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) # <<<<<<<<<<<<<< + * PyNodesel = nodeseldata + * result_dict = PyNodesel.nodeselect() + */ + __pyx_v_nodeseldata = SCIPnodeselGetData(__pyx_v_nodesel); + + /* "src/pyscipopt/nodesel.pxi":88 + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata # <<<<<<<<<<<<<< + * result_dict = PyNodesel.nodeselect() + * selected_node = (result_dict.get("selnode", None)) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_nodeseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyNodesel = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":89 + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata + * result_dict = PyNodesel.nodeselect() # <<<<<<<<<<<<<< + * selected_node = (result_dict.get("selnode", None)) + * selnode[0] = selected_node.scip_node + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyNodesel), __pyx_n_s_nodeselect); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result_dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":90 + * PyNodesel = nodeseldata + * result_dict = PyNodesel.nodeselect() + * selected_node = (result_dict.get("selnode", None)) # <<<<<<<<<<<<<< + * selnode[0] = selected_node.scip_node + * return SCIP_OKAY + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_result_dict, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_selected_node = ((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":91 + * result_dict = PyNodesel.nodeselect() + * selected_node = (result_dict.get("selnode", None)) + * selnode[0] = selected_node.scip_node # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_t_5 = __pyx_v_selected_node->scip_node; + (__pyx_v_selnode[0]) = __pyx_t_5; + + /* "src/pyscipopt/nodesel.pxi":92 + * selected_node = (result_dict.get("selnode", None)) + * selnode[0] = selected_node.scip_node + * return SCIP_OKAY # <<<<<<<<<<<<<< + * + * cdef int PyNodeselComp (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE* node1, SCIP_NODE* node2) noexcept with gil: + */ + __pyx_r = SCIP_OKAY; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":85 + * return SCIP_OKAY + * + * cdef SCIP_RETCODE PyNodeselSelect (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE** selnode) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyNodeselSelect", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyNodesel); + __Pyx_XDECREF(__pyx_v_result_dict); + __Pyx_XDECREF((PyObject *)__pyx_v_selected_node); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "src/pyscipopt/nodesel.pxi":94 + * return SCIP_OKAY + * + * cdef int PyNodeselComp (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE* node1, SCIP_NODE* node2) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + +static int __pyx_f_9pyscipopt_4scip_PyNodeselComp(CYTHON_UNUSED SCIP *__pyx_v_scip, SCIP_NODESEL *__pyx_v_nodesel, SCIP_NODE *__pyx_v_node1, SCIP_NODE *__pyx_v_node2) { + SCIP_NODESELDATA *__pyx_v_nodeseldata; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_PyNodesel = NULL; + PyObject *__pyx_v_n1 = NULL; + PyObject *__pyx_v_n2 = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("PyNodeselComp", 0); + + /* "src/pyscipopt/nodesel.pxi":96 + * cdef int PyNodeselComp (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE* node1, SCIP_NODE* node2) noexcept with gil: + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) # <<<<<<<<<<<<<< + * PyNodesel = nodeseldata + * n1 = Node.create(node1) + */ + __pyx_v_nodeseldata = SCIPnodeselGetData(__pyx_v_nodesel); + + /* "src/pyscipopt/nodesel.pxi":97 + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata # <<<<<<<<<<<<<< + * n1 = Node.create(node1) + * n2 = Node.create(node2) + */ + __pyx_t_1 = ((PyObject *)__pyx_v_nodeseldata); + __Pyx_INCREF(__pyx_t_1); + __pyx_v_PyNodesel = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":98 + * nodeseldata = SCIPnodeselGetData(nodesel) + * PyNodesel = nodeseldata + * n1 = Node.create(node1) # <<<<<<<<<<<<<< + * n2 = Node.create(node2) + * result = PyNodesel.nodecomp(n1, n2) # + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_node1); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_n1 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":99 + * PyNodesel = nodeseldata + * n1 = Node.create(node1) + * n2 = Node.create(node2) # <<<<<<<<<<<<<< + * result = PyNodesel.nodecomp(n1, n2) # + * return result + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_node2); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_n2 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":100 + * n1 = Node.create(node1) + * n2 = Node.create(node2) + * result = PyNodesel.nodecomp(n1, n2) # # <<<<<<<<<<<<<< + * return result + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_PyNodesel), __pyx_n_s_nodecomp); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_v_n1, __pyx_v_n2}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/nodesel.pxi":101 + * n2 = Node.create(node2) + * result = PyNodesel.nodecomp(n1, n2) # + * return result # <<<<<<<<<<<<<< + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_result); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(19, 101, __pyx_L1_error) + __pyx_r = __pyx_t_4; + goto __pyx_L0; + + /* "src/pyscipopt/nodesel.pxi":94 + * return SCIP_OKAY + * + * cdef int PyNodeselComp (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE* node1, SCIP_NODE* node2) noexcept with gil: # <<<<<<<<<<<<<< + * cdef SCIP_NODESELDATA* nodeseldata + * nodeseldata = SCIPnodeselGetData(nodesel) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_WriteUnraisable("pyscipopt.scip.PyNodeselComp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_PyNodesel); + __Pyx_XDECREF(__pyx_v_n1); + __Pyx_XDECREF(__pyx_v_n2); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_14PY_SCIP_RESULT_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_14PY_SCIP_RESULT___reduce_cython__, "PY_SCIP_RESULT.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_14PY_SCIP_RESULT_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_14PY_SCIP_RESULT_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14PY_SCIP_RESULT___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_14PY_SCIP_RESULT_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_14PY_SCIP_RESULT___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_14PY_SCIP_RESULT___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_RESULT); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_RESULT__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_RESULT); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_RESULT.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_RESULT__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_14PY_SCIP_RESULT_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_14PY_SCIP_RESULT_2__setstate_cython__, "PY_SCIP_RESULT.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_14PY_SCIP_RESULT_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_14PY_SCIP_RESULT_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14PY_SCIP_RESULT_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_14PY_SCIP_RESULT_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_RESULT.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_14PY_SCIP_RESULT_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_14PY_SCIP_RESULT_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_RESULT__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_RESULT__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_RESULT__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_RESULT.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING___reduce_cython__, "PY_SCIP_PARAMSETTING.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PARAMSETTING.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_2__setstate_cython__, "PY_SCIP_PARAMSETTING.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PARAMSETTING.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PARAMSETTING.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS___reduce_cython__, "PY_SCIP_PARAMEMPHASIS.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PARAMEMPHASIS.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_2__setstate_cython__, "PY_SCIP_PARAMEMPHASIS.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PARAMEMPHASIS.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PARAMEMPHASIS.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_14PY_SCIP_STATUS_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_14PY_SCIP_STATUS___reduce_cython__, "PY_SCIP_STATUS.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_14PY_SCIP_STATUS_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_14PY_SCIP_STATUS_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14PY_SCIP_STATUS___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_14PY_SCIP_STATUS_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_14PY_SCIP_STATUS___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_14PY_SCIP_STATUS___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_STATUS); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_STATUS__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_STATUS); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_STATUS.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STATUS__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_14PY_SCIP_STATUS_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_14PY_SCIP_STATUS_2__setstate_cython__, "PY_SCIP_STATUS.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_14PY_SCIP_STATUS_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_14PY_SCIP_STATUS_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14PY_SCIP_STATUS_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_14PY_SCIP_STATUS_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_STATUS.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_14PY_SCIP_STATUS_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_14PY_SCIP_STATUS_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_STATUS__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_STATUS__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STATUS__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_STATUS.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_13PY_SCIP_STAGE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_13PY_SCIP_STAGE___reduce_cython__, "PY_SCIP_STAGE.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_13PY_SCIP_STAGE_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13PY_SCIP_STAGE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13PY_SCIP_STAGE___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_13PY_SCIP_STAGE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_13PY_SCIP_STAGE___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_13PY_SCIP_STAGE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_STAGE); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_STAGE__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_STAGE); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_STAGE.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STAGE__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_13PY_SCIP_STAGE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_13PY_SCIP_STAGE_2__setstate_cython__, "PY_SCIP_STAGE.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_13PY_SCIP_STAGE_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13PY_SCIP_STAGE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13PY_SCIP_STAGE_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_13PY_SCIP_STAGE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_STAGE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_13PY_SCIP_STAGE_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_13PY_SCIP_STAGE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_STAGE__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_STAGE__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STAGE__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_STAGE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_16PY_SCIP_NODETYPE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_16PY_SCIP_NODETYPE___reduce_cython__, "PY_SCIP_NODETYPE.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_16PY_SCIP_NODETYPE_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_16PY_SCIP_NODETYPE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_16PY_SCIP_NODETYPE___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_16PY_SCIP_NODETYPE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_16PY_SCIP_NODETYPE___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_16PY_SCIP_NODETYPE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_NODETYPE.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_16PY_SCIP_NODETYPE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_16PY_SCIP_NODETYPE_2__setstate_cython__, "PY_SCIP_NODETYPE.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_16PY_SCIP_NODETYPE_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_16PY_SCIP_NODETYPE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_16PY_SCIP_NODETYPE_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_16PY_SCIP_NODETYPE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_NODETYPE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_16PY_SCIP_NODETYPE_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_16PY_SCIP_NODETYPE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_NODETYPE__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_NODETYPE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_18PY_SCIP_PROPTIMING___reduce_cython__, "PY_SCIP_PROPTIMING.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18PY_SCIP_PROPTIMING___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_18PY_SCIP_PROPTIMING___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_18PY_SCIP_PROPTIMING___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PROPTIMING.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_2__setstate_cython__, "PY_SCIP_PROPTIMING.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PROPTIMING.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PROPTIMING__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PROPTIMING.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING___reduce_cython__, "PY_SCIP_PRESOLTIMING.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PRESOLTIMING.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_2__setstate_cython__, "PY_SCIP_PRESOLTIMING.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PRESOLTIMING.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_PRESOLTIMING.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_18PY_SCIP_HEURTIMING___reduce_cython__, "PY_SCIP_HEURTIMING.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18PY_SCIP_HEURTIMING___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_18PY_SCIP_HEURTIMING___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_18PY_SCIP_HEURTIMING___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_HEURTIMING.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_2__setstate_cython__, "PY_SCIP_HEURTIMING.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_HEURTIMING.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_HEURTIMING__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_HEURTIMING.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE___reduce_cython__, "PY_SCIP_EVENTTYPE.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_EVENTTYPE.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_2__setstate_cython__, "PY_SCIP_EVENTTYPE.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_EVENTTYPE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_EVENTTYPE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT___reduce_cython__, "PY_SCIP_LPSOLSTAT.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_LPSOLSTAT.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_2__setstate_cython__, "PY_SCIP_LPSOLSTAT.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_LPSOLSTAT.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_LPSOLSTAT.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR___reduce_cython__, "PY_SCIP_BRANCHDIR.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_BRANCHDIR.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_2__setstate_cython__, "PY_SCIP_BRANCHDIR.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_BRANCHDIR.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_BRANCHDIR.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE___reduce_cython__, "PY_SCIP_BENDERSENFOTYPE.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_BENDERSENFOTYPE.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_2__setstate_cython__, "PY_SCIP_BENDERSENFOTYPE.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_BENDERSENFOTYPE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_BENDERSENFOTYPE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE___reduce_cython__, "PY_SCIP_ROWORIGINTYPE.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_1__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE___reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE___reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE___reduce_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = () # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __Pyx_INCREF(__pyx_empty_tuple); + __pyx_v_state = __pyx_empty_tuple; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = () + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict)) __PYX_ERR(6, 8, __pyx_L1_error); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = () + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, None), state + */ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, None), state + * else: + */ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(6, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state)) __PYX_ERR(6, 13, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, None), state + * else: + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_238750788); + __Pyx_GIVEREF(__pyx_int_238750788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_238750788)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(6, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(6, 15, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_ROWORIGINTYPE.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_2__setstate_cython__, "PY_SCIP_ROWORIGINTYPE.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_3__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_2__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_ROWORIGINTYPE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_2__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_2__setstate_cython__(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_ROWORIGINTYPE.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":260 + * REOPT = SCIP_ROWORIGINTYPE_REOPT + * + * def PY_SCIP_CALL(SCIP_RETCODE rc): # <<<<<<<<<<<<<< + * if rc == SCIP_OKAY: + * pass + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_27PY_SCIP_CALL(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_26PY_SCIP_CALL, "PY_SCIP_CALL(SCIP_RETCODE rc)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_27PY_SCIP_CALL = {"PY_SCIP_CALL", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_27PY_SCIP_CALL, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_26PY_SCIP_CALL}; +static PyObject *__pyx_pw_9pyscipopt_4scip_27PY_SCIP_CALL(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + SCIP_RETCODE __pyx_v_rc; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("PY_SCIP_CALL (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rc,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 260, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "PY_SCIP_CALL") < 0)) __PYX_ERR(0, 260, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_rc = __Pyx_PyInt_As_SCIP_RETCODE(values[0]); if (unlikely((__pyx_v_rc == ((SCIP_RETCODE)-1)) && PyErr_Occurred())) __PYX_ERR(0, 260, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("PY_SCIP_CALL", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 260, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_CALL", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_26PY_SCIP_CALL(__pyx_self, __pyx_v_rc); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_26PY_SCIP_CALL(CYTHON_UNUSED PyObject *__pyx_self, SCIP_RETCODE __pyx_v_rc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PY_SCIP_CALL", 1); + + /* "src/pyscipopt/scip.pxi":261 + * + * def PY_SCIP_CALL(SCIP_RETCODE rc): + * if rc == SCIP_OKAY: # <<<<<<<<<<<<<< + * pass + * elif rc == SCIP_ERROR: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_OKAY); + if (likely(__pyx_t_1)) { + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":263 + * if rc == SCIP_OKAY: + * pass + * elif rc == SCIP_ERROR: # <<<<<<<<<<<<<< + * raise Exception('SCIP: unspecified error!') + * elif rc == SCIP_NOMEMORY: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_ERROR); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":264 + * pass + * elif rc == SCIP_ERROR: + * raise Exception('SCIP: unspecified error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_NOMEMORY: + * raise MemoryError('SCIP: insufficient memory error!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 264, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":263 + * if rc == SCIP_OKAY: + * pass + * elif rc == SCIP_ERROR: # <<<<<<<<<<<<<< + * raise Exception('SCIP: unspecified error!') + * elif rc == SCIP_NOMEMORY: + */ + } + + /* "src/pyscipopt/scip.pxi":265 + * elif rc == SCIP_ERROR: + * raise Exception('SCIP: unspecified error!') + * elif rc == SCIP_NOMEMORY: # <<<<<<<<<<<<<< + * raise MemoryError('SCIP: insufficient memory error!') + * elif rc == SCIP_READERROR: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_NOMEMORY); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":266 + * raise Exception('SCIP: unspecified error!') + * elif rc == SCIP_NOMEMORY: + * raise MemoryError('SCIP: insufficient memory error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_READERROR: + * raise IOError('SCIP: read error!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 266, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":265 + * elif rc == SCIP_ERROR: + * raise Exception('SCIP: unspecified error!') + * elif rc == SCIP_NOMEMORY: # <<<<<<<<<<<<<< + * raise MemoryError('SCIP: insufficient memory error!') + * elif rc == SCIP_READERROR: + */ + } + + /* "src/pyscipopt/scip.pxi":267 + * elif rc == SCIP_NOMEMORY: + * raise MemoryError('SCIP: insufficient memory error!') + * elif rc == SCIP_READERROR: # <<<<<<<<<<<<<< + * raise IOError('SCIP: read error!') + * elif rc == SCIP_WRITEERROR: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_READERROR); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":268 + * raise MemoryError('SCIP: insufficient memory error!') + * elif rc == SCIP_READERROR: + * raise IOError('SCIP: read error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_WRITEERROR: + * raise IOError('SCIP: write error!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 268, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":267 + * elif rc == SCIP_NOMEMORY: + * raise MemoryError('SCIP: insufficient memory error!') + * elif rc == SCIP_READERROR: # <<<<<<<<<<<<<< + * raise IOError('SCIP: read error!') + * elif rc == SCIP_WRITEERROR: + */ + } + + /* "src/pyscipopt/scip.pxi":269 + * elif rc == SCIP_READERROR: + * raise IOError('SCIP: read error!') + * elif rc == SCIP_WRITEERROR: # <<<<<<<<<<<<<< + * raise IOError('SCIP: write error!') + * elif rc == SCIP_NOFILE: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_WRITEERROR); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":270 + * raise IOError('SCIP: read error!') + * elif rc == SCIP_WRITEERROR: + * raise IOError('SCIP: write error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_NOFILE: + * raise IOError('SCIP: file not found error!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 270, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":269 + * elif rc == SCIP_READERROR: + * raise IOError('SCIP: read error!') + * elif rc == SCIP_WRITEERROR: # <<<<<<<<<<<<<< + * raise IOError('SCIP: write error!') + * elif rc == SCIP_NOFILE: + */ + } + + /* "src/pyscipopt/scip.pxi":271 + * elif rc == SCIP_WRITEERROR: + * raise IOError('SCIP: write error!') + * elif rc == SCIP_NOFILE: # <<<<<<<<<<<<<< + * raise IOError('SCIP: file not found error!') + * elif rc == SCIP_FILECREATEERROR: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_NOFILE); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":272 + * raise IOError('SCIP: write error!') + * elif rc == SCIP_NOFILE: + * raise IOError('SCIP: file not found error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_FILECREATEERROR: + * raise IOError('SCIP: cannot create file!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 272, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":271 + * elif rc == SCIP_WRITEERROR: + * raise IOError('SCIP: write error!') + * elif rc == SCIP_NOFILE: # <<<<<<<<<<<<<< + * raise IOError('SCIP: file not found error!') + * elif rc == SCIP_FILECREATEERROR: + */ + } + + /* "src/pyscipopt/scip.pxi":273 + * elif rc == SCIP_NOFILE: + * raise IOError('SCIP: file not found error!') + * elif rc == SCIP_FILECREATEERROR: # <<<<<<<<<<<<<< + * raise IOError('SCIP: cannot create file!') + * elif rc == SCIP_LPERROR: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_FILECREATEERROR); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":274 + * raise IOError('SCIP: file not found error!') + * elif rc == SCIP_FILECREATEERROR: + * raise IOError('SCIP: cannot create file!') # <<<<<<<<<<<<<< + * elif rc == SCIP_LPERROR: + * raise Exception('SCIP: error in LP solver!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 274, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":273 + * elif rc == SCIP_NOFILE: + * raise IOError('SCIP: file not found error!') + * elif rc == SCIP_FILECREATEERROR: # <<<<<<<<<<<<<< + * raise IOError('SCIP: cannot create file!') + * elif rc == SCIP_LPERROR: + */ + } + + /* "src/pyscipopt/scip.pxi":275 + * elif rc == SCIP_FILECREATEERROR: + * raise IOError('SCIP: cannot create file!') + * elif rc == SCIP_LPERROR: # <<<<<<<<<<<<<< + * raise Exception('SCIP: error in LP solver!') + * elif rc == SCIP_NOPROBLEM: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_LPERROR); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":276 + * raise IOError('SCIP: cannot create file!') + * elif rc == SCIP_LPERROR: + * raise Exception('SCIP: error in LP solver!') # <<<<<<<<<<<<<< + * elif rc == SCIP_NOPROBLEM: + * raise Exception('SCIP: no problem exists!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 276, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":275 + * elif rc == SCIP_FILECREATEERROR: + * raise IOError('SCIP: cannot create file!') + * elif rc == SCIP_LPERROR: # <<<<<<<<<<<<<< + * raise Exception('SCIP: error in LP solver!') + * elif rc == SCIP_NOPROBLEM: + */ + } + + /* "src/pyscipopt/scip.pxi":277 + * elif rc == SCIP_LPERROR: + * raise Exception('SCIP: error in LP solver!') + * elif rc == SCIP_NOPROBLEM: # <<<<<<<<<<<<<< + * raise Exception('SCIP: no problem exists!') + * elif rc == SCIP_INVALIDCALL: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_NOPROBLEM); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":278 + * raise Exception('SCIP: error in LP solver!') + * elif rc == SCIP_NOPROBLEM: + * raise Exception('SCIP: no problem exists!') # <<<<<<<<<<<<<< + * elif rc == SCIP_INVALIDCALL: + * raise Exception('SCIP: method cannot be called at this time' + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 278, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":277 + * elif rc == SCIP_LPERROR: + * raise Exception('SCIP: error in LP solver!') + * elif rc == SCIP_NOPROBLEM: # <<<<<<<<<<<<<< + * raise Exception('SCIP: no problem exists!') + * elif rc == SCIP_INVALIDCALL: + */ + } + + /* "src/pyscipopt/scip.pxi":279 + * elif rc == SCIP_NOPROBLEM: + * raise Exception('SCIP: no problem exists!') + * elif rc == SCIP_INVALIDCALL: # <<<<<<<<<<<<<< + * raise Exception('SCIP: method cannot be called at this time' + * + ' in solution process!') + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_INVALIDCALL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":280 + * raise Exception('SCIP: no problem exists!') + * elif rc == SCIP_INVALIDCALL: + * raise Exception('SCIP: method cannot be called at this time' # <<<<<<<<<<<<<< + * + ' in solution process!') + * elif rc == SCIP_INVALIDDATA: + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 280, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":279 + * elif rc == SCIP_NOPROBLEM: + * raise Exception('SCIP: no problem exists!') + * elif rc == SCIP_INVALIDCALL: # <<<<<<<<<<<<<< + * raise Exception('SCIP: method cannot be called at this time' + * + ' in solution process!') + */ + } + + /* "src/pyscipopt/scip.pxi":282 + * raise Exception('SCIP: method cannot be called at this time' + * + ' in solution process!') + * elif rc == SCIP_INVALIDDATA: # <<<<<<<<<<<<<< + * raise Exception('SCIP: error in input data!') + * elif rc == SCIP_INVALIDRESULT: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_INVALIDDATA); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":283 + * + ' in solution process!') + * elif rc == SCIP_INVALIDDATA: + * raise Exception('SCIP: error in input data!') # <<<<<<<<<<<<<< + * elif rc == SCIP_INVALIDRESULT: + * raise Exception('SCIP: method returned an invalid result code!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 283, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":282 + * raise Exception('SCIP: method cannot be called at this time' + * + ' in solution process!') + * elif rc == SCIP_INVALIDDATA: # <<<<<<<<<<<<<< + * raise Exception('SCIP: error in input data!') + * elif rc == SCIP_INVALIDRESULT: + */ + } + + /* "src/pyscipopt/scip.pxi":284 + * elif rc == SCIP_INVALIDDATA: + * raise Exception('SCIP: error in input data!') + * elif rc == SCIP_INVALIDRESULT: # <<<<<<<<<<<<<< + * raise Exception('SCIP: method returned an invalid result code!') + * elif rc == SCIP_PLUGINNOTFOUND: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_INVALIDRESULT); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":285 + * raise Exception('SCIP: error in input data!') + * elif rc == SCIP_INVALIDRESULT: + * raise Exception('SCIP: method returned an invalid result code!') # <<<<<<<<<<<<<< + * elif rc == SCIP_PLUGINNOTFOUND: + * raise Exception('SCIP: a required plugin was not found !') + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 285, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":284 + * elif rc == SCIP_INVALIDDATA: + * raise Exception('SCIP: error in input data!') + * elif rc == SCIP_INVALIDRESULT: # <<<<<<<<<<<<<< + * raise Exception('SCIP: method returned an invalid result code!') + * elif rc == SCIP_PLUGINNOTFOUND: + */ + } + + /* "src/pyscipopt/scip.pxi":286 + * elif rc == SCIP_INVALIDRESULT: + * raise Exception('SCIP: method returned an invalid result code!') + * elif rc == SCIP_PLUGINNOTFOUND: # <<<<<<<<<<<<<< + * raise Exception('SCIP: a required plugin was not found !') + * elif rc == SCIP_PARAMETERUNKNOWN: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_PLUGINNOTFOUND); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":287 + * raise Exception('SCIP: method returned an invalid result code!') + * elif rc == SCIP_PLUGINNOTFOUND: + * raise Exception('SCIP: a required plugin was not found !') # <<<<<<<<<<<<<< + * elif rc == SCIP_PARAMETERUNKNOWN: + * raise KeyError('SCIP: the parameter with the given name was not found!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 287, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":286 + * elif rc == SCIP_INVALIDRESULT: + * raise Exception('SCIP: method returned an invalid result code!') + * elif rc == SCIP_PLUGINNOTFOUND: # <<<<<<<<<<<<<< + * raise Exception('SCIP: a required plugin was not found !') + * elif rc == SCIP_PARAMETERUNKNOWN: + */ + } + + /* "src/pyscipopt/scip.pxi":288 + * elif rc == SCIP_PLUGINNOTFOUND: + * raise Exception('SCIP: a required plugin was not found !') + * elif rc == SCIP_PARAMETERUNKNOWN: # <<<<<<<<<<<<<< + * raise KeyError('SCIP: the parameter with the given name was not found!') + * elif rc == SCIP_PARAMETERWRONGTYPE: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_PARAMETERUNKNOWN); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":289 + * raise Exception('SCIP: a required plugin was not found !') + * elif rc == SCIP_PARAMETERUNKNOWN: + * raise KeyError('SCIP: the parameter with the given name was not found!') # <<<<<<<<<<<<<< + * elif rc == SCIP_PARAMETERWRONGTYPE: + * raise LookupError('SCIP: the parameter is not of the expected type!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 289, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":288 + * elif rc == SCIP_PLUGINNOTFOUND: + * raise Exception('SCIP: a required plugin was not found !') + * elif rc == SCIP_PARAMETERUNKNOWN: # <<<<<<<<<<<<<< + * raise KeyError('SCIP: the parameter with the given name was not found!') + * elif rc == SCIP_PARAMETERWRONGTYPE: + */ + } + + /* "src/pyscipopt/scip.pxi":290 + * elif rc == SCIP_PARAMETERUNKNOWN: + * raise KeyError('SCIP: the parameter with the given name was not found!') + * elif rc == SCIP_PARAMETERWRONGTYPE: # <<<<<<<<<<<<<< + * raise LookupError('SCIP: the parameter is not of the expected type!') + * elif rc == SCIP_PARAMETERWRONGVAL: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_PARAMETERWRONGTYPE); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":291 + * raise KeyError('SCIP: the parameter with the given name was not found!') + * elif rc == SCIP_PARAMETERWRONGTYPE: + * raise LookupError('SCIP: the parameter is not of the expected type!') # <<<<<<<<<<<<<< + * elif rc == SCIP_PARAMETERWRONGVAL: + * raise ValueError('SCIP: the value is invalid for the given parameter!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_LookupError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 291, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":290 + * elif rc == SCIP_PARAMETERUNKNOWN: + * raise KeyError('SCIP: the parameter with the given name was not found!') + * elif rc == SCIP_PARAMETERWRONGTYPE: # <<<<<<<<<<<<<< + * raise LookupError('SCIP: the parameter is not of the expected type!') + * elif rc == SCIP_PARAMETERWRONGVAL: + */ + } + + /* "src/pyscipopt/scip.pxi":292 + * elif rc == SCIP_PARAMETERWRONGTYPE: + * raise LookupError('SCIP: the parameter is not of the expected type!') + * elif rc == SCIP_PARAMETERWRONGVAL: # <<<<<<<<<<<<<< + * raise ValueError('SCIP: the value is invalid for the given parameter!') + * elif rc == SCIP_KEYALREADYEXISTING: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_PARAMETERWRONGVAL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":293 + * raise LookupError('SCIP: the parameter is not of the expected type!') + * elif rc == SCIP_PARAMETERWRONGVAL: + * raise ValueError('SCIP: the value is invalid for the given parameter!') # <<<<<<<<<<<<<< + * elif rc == SCIP_KEYALREADYEXISTING: + * raise KeyError('SCIP: the given key is already existing in table!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 293, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":292 + * elif rc == SCIP_PARAMETERWRONGTYPE: + * raise LookupError('SCIP: the parameter is not of the expected type!') + * elif rc == SCIP_PARAMETERWRONGVAL: # <<<<<<<<<<<<<< + * raise ValueError('SCIP: the value is invalid for the given parameter!') + * elif rc == SCIP_KEYALREADYEXISTING: + */ + } + + /* "src/pyscipopt/scip.pxi":294 + * elif rc == SCIP_PARAMETERWRONGVAL: + * raise ValueError('SCIP: the value is invalid for the given parameter!') + * elif rc == SCIP_KEYALREADYEXISTING: # <<<<<<<<<<<<<< + * raise KeyError('SCIP: the given key is already existing in table!') + * elif rc == SCIP_MAXDEPTHLEVEL: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_KEYALREADYEXISTING); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":295 + * raise ValueError('SCIP: the value is invalid for the given parameter!') + * elif rc == SCIP_KEYALREADYEXISTING: + * raise KeyError('SCIP: the given key is already existing in table!') # <<<<<<<<<<<<<< + * elif rc == SCIP_MAXDEPTHLEVEL: + * raise Exception('SCIP: maximal branching depth level exceeded!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 295, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":294 + * elif rc == SCIP_PARAMETERWRONGVAL: + * raise ValueError('SCIP: the value is invalid for the given parameter!') + * elif rc == SCIP_KEYALREADYEXISTING: # <<<<<<<<<<<<<< + * raise KeyError('SCIP: the given key is already existing in table!') + * elif rc == SCIP_MAXDEPTHLEVEL: + */ + } + + /* "src/pyscipopt/scip.pxi":296 + * elif rc == SCIP_KEYALREADYEXISTING: + * raise KeyError('SCIP: the given key is already existing in table!') + * elif rc == SCIP_MAXDEPTHLEVEL: # <<<<<<<<<<<<<< + * raise Exception('SCIP: maximal branching depth level exceeded!') + * else: + */ + __pyx_t_1 = (__pyx_v_rc == SCIP_MAXDEPTHLEVEL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":297 + * raise KeyError('SCIP: the given key is already existing in table!') + * elif rc == SCIP_MAXDEPTHLEVEL: + * raise Exception('SCIP: maximal branching depth level exceeded!') # <<<<<<<<<<<<<< + * else: + * raise Exception('SCIP: unknown return code!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 297, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":296 + * elif rc == SCIP_KEYALREADYEXISTING: + * raise KeyError('SCIP: the given key is already existing in table!') + * elif rc == SCIP_MAXDEPTHLEVEL: # <<<<<<<<<<<<<< + * raise Exception('SCIP: maximal branching depth level exceeded!') + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":299 + * raise Exception('SCIP: maximal branching depth level exceeded!') + * else: + * raise Exception('SCIP: unknown return code!') # <<<<<<<<<<<<<< + * + * cdef class Event: + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 299, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":260 + * REOPT = SCIP_ROWORIGINTYPE_REOPT + * + * def PY_SCIP_CALL(SCIP_RETCODE rc): # <<<<<<<<<<<<<< + * if rc == SCIP_OKAY: + * pass + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.PY_SCIP_CALL", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":305 + * + * @staticmethod + * cdef create(SCIP_EVENT* scip_event): # <<<<<<<<<<<<<< + * if scip_event == NULL: + * raise Warning("cannot create Event with SCIP_EVENT* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_5Event_create(SCIP_EVENT *__pyx_v_scip_event) { + struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_event = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":306 + * @staticmethod + * cdef create(SCIP_EVENT* scip_event): + * if scip_event == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Event with SCIP_EVENT* == NULL") + * event = Event() + */ + __pyx_t_1 = (__pyx_v_scip_event == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":307 + * cdef create(SCIP_EVENT* scip_event): + * if scip_event == NULL: + * raise Warning("cannot create Event with SCIP_EVENT* == NULL") # <<<<<<<<<<<<<< + * event = Event() + * event.event = scip_event + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 307, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":306 + * @staticmethod + * cdef create(SCIP_EVENT* scip_event): + * if scip_event == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Event with SCIP_EVENT* == NULL") + * event = Event() + */ + } + + /* "src/pyscipopt/scip.pxi":308 + * if scip_event == NULL: + * raise Warning("cannot create Event with SCIP_EVENT* == NULL") + * event = Event() # <<<<<<<<<<<<<< + * event.event = scip_event + * return event + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_event = ((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":309 + * raise Warning("cannot create Event with SCIP_EVENT* == NULL") + * event = Event() + * event.event = scip_event # <<<<<<<<<<<<<< + * return event + * + */ + __pyx_v_event->event = __pyx_v_scip_event; + + /* "src/pyscipopt/scip.pxi":310 + * event = Event() + * event.event = scip_event + * return event # <<<<<<<<<<<<<< + * + * def getType(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_event); + __pyx_r = ((PyObject *)__pyx_v_event); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":305 + * + * @staticmethod + * cdef create(SCIP_EVENT* scip_event): # <<<<<<<<<<<<<< + * if scip_event == NULL: + * raise Warning("cannot create Event with SCIP_EVENT* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Event.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_event); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":312 + * return event + * + * def getType(self): # <<<<<<<<<<<<<< + * """gets type of event""" + * return SCIPeventGetType(self.event) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_1getType(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_getType, "Event.getType(self)\ngets type of event"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_1getType = {"getType", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_1getType, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_getType}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_1getType(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getType (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_getType(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_getType(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getType", 1); + + /* "src/pyscipopt/scip.pxi":314 + * def getType(self): + * """gets type of event""" + * return SCIPeventGetType(self.event) # <<<<<<<<<<<<<< + * + * def getName(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIPeventGetType(__pyx_v_self->event)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":312 + * return event + * + * def getType(self): # <<<<<<<<<<<<<< + * """gets type of event""" + * return SCIPeventGetType(self.event) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Event.getType", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":316 + * return SCIPeventGetType(self.event) + * + * def getName(self): # <<<<<<<<<<<<<< + * """gets name of event""" + * if not EventNames: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_3getName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_2getName, "Event.getName(self)\ngets name of event"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_3getName = {"getName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_3getName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_2getName}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_3getName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getName (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getName", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getName", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_2getName(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_2getName(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getName", 1); + + /* "src/pyscipopt/scip.pxi":318 + * def getName(self): + * """gets name of event""" + * if not EventNames: # <<<<<<<<<<<<<< + * self._getEventNames() + * return EventNames[self.getType()] + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_EventNames); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (!__pyx_t_2); + if (__pyx_t_3) { + + /* "src/pyscipopt/scip.pxi":319 + * """gets name of event""" + * if not EventNames: + * self._getEventNames() # <<<<<<<<<<<<<< + * return EventNames[self.getType()] + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getEventNames); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":318 + * def getName(self): + * """gets name of event""" + * if not EventNames: # <<<<<<<<<<<<<< + * self._getEventNames() + * return EventNames[self.getType()] + */ + } + + /* "src/pyscipopt/scip.pxi":320 + * if not EventNames: + * self._getEventNames() + * return EventNames[self.getType()] # <<<<<<<<<<<<<< + * + * def _getEventNames(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_EventNames); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getType); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":316 + * return SCIPeventGetType(self.event) + * + * def getName(self): # <<<<<<<<<<<<<< + * """gets name of event""" + * if not EventNames: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Event.getName", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":322 + * return EventNames[self.getType()] + * + * def _getEventNames(self): # <<<<<<<<<<<<<< + * """gets event names""" + * for name in dir(PY_SCIP_EVENTTYPE): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_5_getEventNames(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_4_getEventNames, "Event._getEventNames(self)\ngets event names"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_5_getEventNames = {"_getEventNames", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_5_getEventNames, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_4_getEventNames}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_5_getEventNames(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_getEventNames (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("_getEventNames", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "_getEventNames", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_4_getEventNames(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_4_getEventNames(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_v_attr = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_getEventNames", 1); + + /* "src/pyscipopt/scip.pxi":324 + * def _getEventNames(self): + * """gets event names""" + * for name in dir(PY_SCIP_EVENTTYPE): # <<<<<<<<<<<<<< + * attr = getattr(PY_SCIP_EVENTTYPE, name) + * if isinstance(attr, int): + */ + __pyx_t_1 = PyObject_Dir(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 324, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 324, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 324, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 324, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 324, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 324, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":325 + * """gets event names""" + * for name in dir(PY_SCIP_EVENTTYPE): + * attr = getattr(PY_SCIP_EVENTTYPE, name) # <<<<<<<<<<<<<< + * if isinstance(attr, int): + * EventNames[attr] = name + */ + __pyx_t_1 = __Pyx_GetAttr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE), __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_attr, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":326 + * for name in dir(PY_SCIP_EVENTTYPE): + * attr = getattr(PY_SCIP_EVENTTYPE, name) + * if isinstance(attr, int): # <<<<<<<<<<<<<< + * EventNames[attr] = name + * + */ + __pyx_t_5 = PyInt_Check(__pyx_v_attr); + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":327 + * attr = getattr(PY_SCIP_EVENTTYPE, name) + * if isinstance(attr, int): + * EventNames[attr] = name # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_EventNames); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_attr, __pyx_v_name) < 0))) __PYX_ERR(0, 327, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":326 + * for name in dir(PY_SCIP_EVENTTYPE): + * attr = getattr(PY_SCIP_EVENTTYPE, name) + * if isinstance(attr, int): # <<<<<<<<<<<<<< + * EventNames[attr] = name + * + */ + } + + /* "src/pyscipopt/scip.pxi":324 + * def _getEventNames(self): + * """gets event names""" + * for name in dir(PY_SCIP_EVENTTYPE): # <<<<<<<<<<<<<< + * attr = getattr(PY_SCIP_EVENTTYPE, name) + * if isinstance(attr, int): + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":322 + * return EventNames[self.getType()] + * + * def _getEventNames(self): # <<<<<<<<<<<<<< + * """gets event names""" + * for name in dir(PY_SCIP_EVENTTYPE): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Event._getEventNames", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_attr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":329 + * EventNames[attr] = name + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return str(self.getType()) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_7__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_7__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_6__repr__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_6__repr__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/scip.pxi":330 + * + * def __repr__(self): + * return str(self.getType()) # <<<<<<<<<<<<<< + * + * def __str__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getType); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyObject_Str(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":329 + * EventNames[attr] = name + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return str(self.getType()) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Event.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":332 + * return str(self.getType()) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return self.getName() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_9__str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_9__str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_8__str__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_8__str__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 1); + + /* "src/pyscipopt/scip.pxi":333 + * + * def __str__(self): + * return self.getName() # <<<<<<<<<<<<<< + * + * def getNewBound(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getName); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":332 + * return str(self.getType()) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return self.getName() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Event.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":335 + * return self.getName() + * + * def getNewBound(self): # <<<<<<<<<<<<<< + * """gets new bound for a bound change event""" + * return SCIPeventGetNewbound(self.event) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_11getNewBound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_10getNewBound, "Event.getNewBound(self)\ngets new bound for a bound change event"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_11getNewBound = {"getNewBound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_11getNewBound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_10getNewBound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_11getNewBound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNewBound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNewBound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNewBound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_10getNewBound(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_10getNewBound(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNewBound", 1); + + /* "src/pyscipopt/scip.pxi":337 + * def getNewBound(self): + * """gets new bound for a bound change event""" + * return SCIPeventGetNewbound(self.event) # <<<<<<<<<<<<<< + * + * def getOldBound(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPeventGetNewbound(__pyx_v_self->event)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":335 + * return self.getName() + * + * def getNewBound(self): # <<<<<<<<<<<<<< + * """gets new bound for a bound change event""" + * return SCIPeventGetNewbound(self.event) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Event.getNewBound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":339 + * return SCIPeventGetNewbound(self.event) + * + * def getOldBound(self): # <<<<<<<<<<<<<< + * """gets old bound for a bound change event""" + * return SCIPeventGetOldbound(self.event) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_13getOldBound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_12getOldBound, "Event.getOldBound(self)\ngets old bound for a bound change event"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_13getOldBound = {"getOldBound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_13getOldBound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_12getOldBound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_13getOldBound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getOldBound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getOldBound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOldBound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_12getOldBound(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_12getOldBound(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getOldBound", 1); + + /* "src/pyscipopt/scip.pxi":341 + * def getOldBound(self): + * """gets old bound for a bound change event""" + * return SCIPeventGetOldbound(self.event) # <<<<<<<<<<<<<< + * + * def getVar(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPeventGetOldbound(__pyx_v_self->event)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":339 + * return SCIPeventGetNewbound(self.event) + * + * def getOldBound(self): # <<<<<<<<<<<<<< + * """gets old bound for a bound change event""" + * return SCIPeventGetOldbound(self.event) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Event.getOldBound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":343 + * return SCIPeventGetOldbound(self.event) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)""" + * cdef SCIP_VAR* var = SCIPeventGetVar(self.event) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_15getVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_14getVar, "Event.getVar(self)\ngets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_15getVar = {"getVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_15getVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_14getVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_15getVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getVar", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getVar", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_14getVar(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_14getVar(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + SCIP_VAR *__pyx_v_var; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVar", 1); + + /* "src/pyscipopt/scip.pxi":345 + * def getVar(self): + * """gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)""" + * cdef SCIP_VAR* var = SCIPeventGetVar(self.event) # <<<<<<<<<<<<<< + * return Variable.create(var) + * + */ + __pyx_v_var = SCIPeventGetVar(__pyx_v_self->event); + + /* "src/pyscipopt/scip.pxi":346 + * """gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)""" + * cdef SCIP_VAR* var = SCIPeventGetVar(self.event) + * return Variable.create(var) # <<<<<<<<<<<<<< + * + * def getNode(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v_var); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":343 + * return SCIPeventGetOldbound(self.event) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)""" + * cdef SCIP_VAR* var = SCIPeventGetVar(self.event) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Event.getVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":348 + * return Variable.create(var) + * + * def getNode(self): # <<<<<<<<<<<<<< + * """gets node for a node or LP event""" + * cdef SCIP_NODE* node = SCIPeventGetNode(self.event) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_17getNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_16getNode, "Event.getNode(self)\ngets node for a node or LP event"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_17getNode = {"getNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_17getNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_16getNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_17getNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNode", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNode", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_16getNode(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_16getNode(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + SCIP_NODE *__pyx_v_node; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNode", 1); + + /* "src/pyscipopt/scip.pxi":350 + * def getNode(self): + * """gets node for a node or LP event""" + * cdef SCIP_NODE* node = SCIPeventGetNode(self.event) # <<<<<<<<<<<<<< + * return Node.create(node) + * + */ + __pyx_v_node = SCIPeventGetNode(__pyx_v_self->event); + + /* "src/pyscipopt/scip.pxi":351 + * """gets node for a node or LP event""" + * cdef SCIP_NODE* node = SCIPeventGetNode(self.event) + * return Node.create(node) # <<<<<<<<<<<<<< + * + * def getRow(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_node); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":348 + * return Variable.create(var) + * + * def getNode(self): # <<<<<<<<<<<<<< + * """gets node for a node or LP event""" + * cdef SCIP_NODE* node = SCIPeventGetNode(self.event) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Event.getNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":353 + * return Node.create(node) + * + * def getRow(self): # <<<<<<<<<<<<<< + * """gets row for a row event""" + * cdef SCIP_ROW* row = SCIPeventGetRow(self.event) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_19getRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_18getRow, "Event.getRow(self)\ngets row for a row event"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_19getRow = {"getRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_19getRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_18getRow}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_19getRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRow (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getRow", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRow", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_18getRow(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_18getRow(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + SCIP_ROW *__pyx_v_row; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRow", 1); + + /* "src/pyscipopt/scip.pxi":355 + * def getRow(self): + * """gets row for a row event""" + * cdef SCIP_ROW* row = SCIPeventGetRow(self.event) # <<<<<<<<<<<<<< + * return Row.create(row) + * + */ + __pyx_v_row = SCIPeventGetRow(__pyx_v_self->event); + + /* "src/pyscipopt/scip.pxi":356 + * """gets row for a row event""" + * cdef SCIP_ROW* row = SCIPeventGetRow(self.event) + * return Row.create(row) # <<<<<<<<<<<<<< + * + * def __hash__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_3Row_create(__pyx_v_row); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":353 + * return Node.create(node) + * + * def getRow(self): # <<<<<<<<<<<<<< + * """gets row for a row event""" + * cdef SCIP_ROW* row = SCIPeventGetRow(self.event) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Event.getRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":358 + * return Row.create(row) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.event) + * + */ + +/* Python wrapper */ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_5Event_21__hash__(PyObject *__pyx_v_self); /*proto*/ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_5Event_21__hash__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_20__hash__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_hash_t __pyx_pf_9pyscipopt_4scip_5Event_20__hash__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_hash_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__hash__", 1); + + /* "src/pyscipopt/scip.pxi":359 + * + * def __hash__(self): + * return hash(self.event) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->event)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":358 + * return Row.create(row) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.event) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Event.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":361 + * return hash(self.event) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.event == (other).event) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_23__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_23__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_22__eq__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_22__eq__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "src/pyscipopt/scip.pxi":362 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.event == (other).event) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "src/pyscipopt/scip.pxi":363 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.event == (other).event) # <<<<<<<<<<<<<< + * + * cdef class Column: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":362 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.event == (other).event) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 362, __pyx_L1_error) + if (__pyx_t_5) { + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "src/pyscipopt/scip.pxi":363 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.event == (other).event) # <<<<<<<<<<<<<< + * + * cdef class Column: + */ + __pyx_t_5 = (__pyx_v_self->event == ((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_other)->event); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":361 + * return hash(self.event) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.event == (other).event) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Event.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1872 + * cdef SCIP_EVENT* event + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * @staticmethod + * cdef create(SCIP_EVENT* scip_event) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Event_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Event_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Event_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Event_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Event_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Event_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_25__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_24__reduce_cython__, "Event.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_25__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_25__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_24__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_25__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_24__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_24__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.event cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_event_cannot_be_converted_t, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Event.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_27__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Event_26__setstate_cython__, "Event.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Event_27__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_27__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_26__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Event_27__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Event.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Event_26__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Event *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Event_26__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Event *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.event cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_event_cannot_be_converted_t, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Event.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":369 + * + * @staticmethod + * cdef create(SCIP_COL* scipcol): # <<<<<<<<<<<<<< + * if scipcol == NULL: + * raise Warning("cannot create Column with SCIP_COL* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_6Column_create(SCIP_COL *__pyx_v_scipcol) { + struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_col = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":370 + * @staticmethod + * cdef create(SCIP_COL* scipcol): + * if scipcol == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Column with SCIP_COL* == NULL") + * col = Column() + */ + __pyx_t_1 = (__pyx_v_scipcol == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":371 + * cdef create(SCIP_COL* scipcol): + * if scipcol == NULL: + * raise Warning("cannot create Column with SCIP_COL* == NULL") # <<<<<<<<<<<<<< + * col = Column() + * col.scip_col = scipcol + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 371, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":370 + * @staticmethod + * cdef create(SCIP_COL* scipcol): + * if scipcol == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Column with SCIP_COL* == NULL") + * col = Column() + */ + } + + /* "src/pyscipopt/scip.pxi":372 + * if scipcol == NULL: + * raise Warning("cannot create Column with SCIP_COL* == NULL") + * col = Column() # <<<<<<<<<<<<<< + * col.scip_col = scipcol + * return col + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_col = ((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":373 + * raise Warning("cannot create Column with SCIP_COL* == NULL") + * col = Column() + * col.scip_col = scipcol # <<<<<<<<<<<<<< + * return col + * + */ + __pyx_v_col->scip_col = __pyx_v_scipcol; + + /* "src/pyscipopt/scip.pxi":374 + * col = Column() + * col.scip_col = scipcol + * return col # <<<<<<<<<<<<<< + * + * def getLPPos(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_col); + __pyx_r = ((PyObject *)__pyx_v_col); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":369 + * + * @staticmethod + * cdef create(SCIP_COL* scipcol): # <<<<<<<<<<<<<< + * if scipcol == NULL: + * raise Warning("cannot create Column with SCIP_COL* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Column.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_col); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":376 + * return col + * + * def getLPPos(self): # <<<<<<<<<<<<<< + * """gets position of column in current LP, or -1 if it is not in LP""" + * return SCIPcolGetLPPos(self.scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_1getLPPos(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_getLPPos, "Column.getLPPos(self)\ngets position of column in current LP, or -1 if it is not in LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_1getLPPos = {"getLPPos", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_1getLPPos, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_getLPPos}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_1getLPPos(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPPos (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPPos", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPPos", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_getLPPos(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_getLPPos(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPPos", 1); + + /* "src/pyscipopt/scip.pxi":378 + * def getLPPos(self): + * """gets position of column in current LP, or -1 if it is not in LP""" + * return SCIPcolGetLPPos(self.scip_col) # <<<<<<<<<<<<<< + * + * def getBasisStatus(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPcolGetLPPos(__pyx_v_self->scip_col)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":376 + * return col + * + * def getLPPos(self): # <<<<<<<<<<<<<< + * """gets position of column in current LP, or -1 if it is not in LP""" + * return SCIPcolGetLPPos(self.scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Column.getLPPos", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":380 + * return SCIPcolGetLPPos(self.scip_col) + * + * def getBasisStatus(self): # <<<<<<<<<<<<<< + * """gets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_3getBasisStatus(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_2getBasisStatus, "Column.getBasisStatus(self)\ngets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_3getBasisStatus = {"getBasisStatus", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_3getBasisStatus, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_2getBasisStatus}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_3getBasisStatus(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBasisStatus (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBasisStatus", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBasisStatus", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_2getBasisStatus(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_2getBasisStatus(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + SCIP_BASESTAT __pyx_v_stat; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBasisStatus", 1); + + /* "src/pyscipopt/scip.pxi":382 + * def getBasisStatus(self): + * """gets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col) # <<<<<<<<<<<<<< + * if stat == SCIP_BASESTAT_LOWER: + * return "lower" + */ + __pyx_v_stat = SCIPcolGetBasisStatus(__pyx_v_self->scip_col); + + /* "src/pyscipopt/scip.pxi":383 + * """gets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col) + * if stat == SCIP_BASESTAT_LOWER: # <<<<<<<<<<<<<< + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_BASESTAT_LOWER); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":384 + * cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col) + * if stat == SCIP_BASESTAT_LOWER: + * return "lower" # <<<<<<<<<<<<<< + * elif stat == SCIP_BASESTAT_BASIC: + * return "basic" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_lower); + __pyx_r = __pyx_n_u_lower; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":383 + * """gets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col) + * if stat == SCIP_BASESTAT_LOWER: # <<<<<<<<<<<<<< + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: + */ + } + + /* "src/pyscipopt/scip.pxi":385 + * if stat == SCIP_BASESTAT_LOWER: + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: # <<<<<<<<<<<<<< + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_BASESTAT_BASIC); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":386 + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: + * return "basic" # <<<<<<<<<<<<<< + * elif stat == SCIP_BASESTAT_UPPER: + * return "upper" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_basic); + __pyx_r = __pyx_n_u_basic; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":385 + * if stat == SCIP_BASESTAT_LOWER: + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: # <<<<<<<<<<<<<< + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: + */ + } + + /* "src/pyscipopt/scip.pxi":387 + * elif stat == SCIP_BASESTAT_BASIC: + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: # <<<<<<<<<<<<<< + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_BASESTAT_UPPER); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":388 + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: + * return "upper" # <<<<<<<<<<<<<< + * elif stat == SCIP_BASESTAT_ZERO: + * return "zero" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_upper); + __pyx_r = __pyx_n_u_upper; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":387 + * elif stat == SCIP_BASESTAT_BASIC: + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: # <<<<<<<<<<<<<< + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: + */ + } + + /* "src/pyscipopt/scip.pxi":389 + * elif stat == SCIP_BASESTAT_UPPER: + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: # <<<<<<<<<<<<<< + * return "zero" + * else: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_BASESTAT_ZERO); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":390 + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: + * return "zero" # <<<<<<<<<<<<<< + * else: + * raise Exception('SCIP returned unknown base status!') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_zero); + __pyx_r = __pyx_n_u_zero; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":389 + * elif stat == SCIP_BASESTAT_UPPER: + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: # <<<<<<<<<<<<<< + * return "zero" + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":392 + * return "zero" + * else: + * raise Exception('SCIP returned unknown base status!') # <<<<<<<<<<<<<< + * + * def isIntegral(self): + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 392, __pyx_L1_error) + } + + /* "src/pyscipopt/scip.pxi":380 + * return SCIPcolGetLPPos(self.scip_col) + * + * def getBasisStatus(self): # <<<<<<<<<<<<<< + * """gets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Column.getBasisStatus", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":394 + * raise Exception('SCIP returned unknown base status!') + * + * def isIntegral(self): # <<<<<<<<<<<<<< + * """returns whether the associated variable is of integral type (binary, integer, implicit integer)""" + * return SCIPcolIsIntegral(self.scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_5isIntegral(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_4isIntegral, "Column.isIntegral(self)\nreturns whether the associated variable is of integral type (binary, integer, implicit integer)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_5isIntegral = {"isIntegral", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_5isIntegral, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_4isIntegral}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_5isIntegral(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isIntegral (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isIntegral", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isIntegral", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_4isIntegral(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_4isIntegral(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isIntegral", 1); + + /* "src/pyscipopt/scip.pxi":396 + * def isIntegral(self): + * """returns whether the associated variable is of integral type (binary, integer, implicit integer)""" + * return SCIPcolIsIntegral(self.scip_col) # <<<<<<<<<<<<<< + * + * def getVar(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPcolIsIntegral(__pyx_v_self->scip_col)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":394 + * raise Exception('SCIP returned unknown base status!') + * + * def isIntegral(self): # <<<<<<<<<<<<<< + * """returns whether the associated variable is of integral type (binary, integer, implicit integer)""" + * return SCIPcolIsIntegral(self.scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Column.isIntegral", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":398 + * return SCIPcolIsIntegral(self.scip_col) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """gets variable this column represents""" + * cdef SCIP_VAR* var = SCIPcolGetVar(self.scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_7getVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_6getVar, "Column.getVar(self)\ngets variable this column represents"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_7getVar = {"getVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_7getVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_6getVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_7getVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getVar", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getVar", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_6getVar(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_6getVar(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + SCIP_VAR *__pyx_v_var; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVar", 1); + + /* "src/pyscipopt/scip.pxi":400 + * def getVar(self): + * """gets variable this column represents""" + * cdef SCIP_VAR* var = SCIPcolGetVar(self.scip_col) # <<<<<<<<<<<<<< + * return Variable.create(var) + * + */ + __pyx_v_var = SCIPcolGetVar(__pyx_v_self->scip_col); + + /* "src/pyscipopt/scip.pxi":401 + * """gets variable this column represents""" + * cdef SCIP_VAR* var = SCIPcolGetVar(self.scip_col) + * return Variable.create(var) # <<<<<<<<<<<<<< + * + * def getPrimsol(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v_var); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 401, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":398 + * return SCIPcolIsIntegral(self.scip_col) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """gets variable this column represents""" + * cdef SCIP_VAR* var = SCIPcolGetVar(self.scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Column.getVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":403 + * return Variable.create(var) + * + * def getPrimsol(self): # <<<<<<<<<<<<<< + * """gets the primal LP solution of a column""" + * return SCIPcolGetPrimsol(self.scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_9getPrimsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_8getPrimsol, "Column.getPrimsol(self)\ngets the primal LP solution of a column"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_9getPrimsol = {"getPrimsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_9getPrimsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_8getPrimsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_9getPrimsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPrimsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getPrimsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPrimsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_8getPrimsol(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_8getPrimsol(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getPrimsol", 1); + + /* "src/pyscipopt/scip.pxi":405 + * def getPrimsol(self): + * """gets the primal LP solution of a column""" + * return SCIPcolGetPrimsol(self.scip_col) # <<<<<<<<<<<<<< + * + * def getLb(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPcolGetPrimsol(__pyx_v_self->scip_col)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":403 + * return Variable.create(var) + * + * def getPrimsol(self): # <<<<<<<<<<<<<< + * """gets the primal LP solution of a column""" + * return SCIPcolGetPrimsol(self.scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Column.getPrimsol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":407 + * return SCIPcolGetPrimsol(self.scip_col) + * + * def getLb(self): # <<<<<<<<<<<<<< + * """gets lower bound of column""" + * return SCIPcolGetLb(self.scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_11getLb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_10getLb, "Column.getLb(self)\ngets lower bound of column"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_11getLb = {"getLb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_11getLb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_10getLb}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_11getLb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLb (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLb", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLb", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_10getLb(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_10getLb(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLb", 1); + + /* "src/pyscipopt/scip.pxi":409 + * def getLb(self): + * """gets lower bound of column""" + * return SCIPcolGetLb(self.scip_col) # <<<<<<<<<<<<<< + * + * def getUb(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPcolGetLb(__pyx_v_self->scip_col)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":407 + * return SCIPcolGetPrimsol(self.scip_col) + * + * def getLb(self): # <<<<<<<<<<<<<< + * """gets lower bound of column""" + * return SCIPcolGetLb(self.scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Column.getLb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":411 + * return SCIPcolGetLb(self.scip_col) + * + * def getUb(self): # <<<<<<<<<<<<<< + * """gets upper bound of column""" + * return SCIPcolGetUb(self.scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_13getUb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_12getUb, "Column.getUb(self)\ngets upper bound of column"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_13getUb = {"getUb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_13getUb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_12getUb}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_13getUb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getUb (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getUb", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getUb", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_12getUb(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_12getUb(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getUb", 1); + + /* "src/pyscipopt/scip.pxi":413 + * def getUb(self): + * """gets upper bound of column""" + * return SCIPcolGetUb(self.scip_col) # <<<<<<<<<<<<<< + * + * def getObjCoeff(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPcolGetUb(__pyx_v_self->scip_col)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":411 + * return SCIPcolGetLb(self.scip_col) + * + * def getUb(self): # <<<<<<<<<<<<<< + * """gets upper bound of column""" + * return SCIPcolGetUb(self.scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Column.getUb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":415 + * return SCIPcolGetUb(self.scip_col) + * + * def getObjCoeff(self): # <<<<<<<<<<<<<< + * """gets objective value coefficient of a column""" + * return SCIPcolGetObj(self.scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_15getObjCoeff(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_14getObjCoeff, "Column.getObjCoeff(self)\ngets objective value coefficient of a column"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_15getObjCoeff = {"getObjCoeff", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_15getObjCoeff, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_14getObjCoeff}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_15getObjCoeff(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getObjCoeff (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getObjCoeff", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getObjCoeff", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_14getObjCoeff(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_14getObjCoeff(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getObjCoeff", 1); + + /* "src/pyscipopt/scip.pxi":417 + * def getObjCoeff(self): + * """gets objective value coefficient of a column""" + * return SCIPcolGetObj(self.scip_col) # <<<<<<<<<<<<<< + * + * def __hash__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPcolGetObj(__pyx_v_self->scip_col)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":415 + * return SCIPcolGetUb(self.scip_col) + * + * def getObjCoeff(self): # <<<<<<<<<<<<<< + * """gets objective value coefficient of a column""" + * return SCIPcolGetObj(self.scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Column.getObjCoeff", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":419 + * return SCIPcolGetObj(self.scip_col) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_col) + * + */ + +/* Python wrapper */ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_6Column_17__hash__(PyObject *__pyx_v_self); /*proto*/ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_6Column_17__hash__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_16__hash__(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_hash_t __pyx_pf_9pyscipopt_4scip_6Column_16__hash__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_hash_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__hash__", 1); + + /* "src/pyscipopt/scip.pxi":420 + * + * def __hash__(self): + * return hash(self.scip_col) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->scip_col)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 420, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":419 + * return SCIPcolGetObj(self.scip_col) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_col) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Column.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":422 + * return hash(self.scip_col) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_col == (other).scip_col) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_19__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_19__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_18__eq__(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_18__eq__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "src/pyscipopt/scip.pxi":423 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_col == (other).scip_col) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "src/pyscipopt/scip.pxi":424 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_col == (other).scip_col) # <<<<<<<<<<<<<< + * + * cdef class Row: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":423 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_col == (other).scip_col) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 423, __pyx_L1_error) + if (__pyx_t_5) { + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "src/pyscipopt/scip.pxi":424 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_col == (other).scip_col) # <<<<<<<<<<<<<< + * + * cdef class Row: + */ + __pyx_t_5 = (__pyx_v_self->scip_col == ((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_other)->scip_col); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":422 + * return hash(self.scip_col) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_col == (other).scip_col) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Column.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1879 + * cdef SCIP_COL* scip_col + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * + * @staticmethod + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Column_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Column_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Column_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_6Column_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_6Column_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_6Column_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_21__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_20__reduce_cython__, "Column.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_21__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_21__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_20__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_21__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_20__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_20__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_col_cannot_be_converte, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Column.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_23__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_6Column_22__setstate_cython__, "Column.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_6Column_23__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_23__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_22__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_6Column_23__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Column.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_6Column_22__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Column *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_6Column_22__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Column *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_col_cannot_be_converte, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Column.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":430 + * + * @staticmethod + * cdef create(SCIP_ROW* sciprow): # <<<<<<<<<<<<<< + * if sciprow == NULL: + * raise Warning("cannot create Row with SCIP_ROW* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_3Row_create(SCIP_ROW *__pyx_v_sciprow) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":431 + * @staticmethod + * cdef create(SCIP_ROW* sciprow): + * if sciprow == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Row with SCIP_ROW* == NULL") + * row = Row() + */ + __pyx_t_1 = (__pyx_v_sciprow == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":432 + * cdef create(SCIP_ROW* sciprow): + * if sciprow == NULL: + * raise Warning("cannot create Row with SCIP_ROW* == NULL") # <<<<<<<<<<<<<< + * row = Row() + * row.scip_row = sciprow + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 432, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":431 + * @staticmethod + * cdef create(SCIP_ROW* sciprow): + * if sciprow == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Row with SCIP_ROW* == NULL") + * row = Row() + */ + } + + /* "src/pyscipopt/scip.pxi":433 + * if sciprow == NULL: + * raise Warning("cannot create Row with SCIP_ROW* == NULL") + * row = Row() # <<<<<<<<<<<<<< + * row.scip_row = sciprow + * return row + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 433, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":434 + * raise Warning("cannot create Row with SCIP_ROW* == NULL") + * row = Row() + * row.scip_row = sciprow # <<<<<<<<<<<<<< + * return row + * + */ + __pyx_v_row->scip_row = __pyx_v_sciprow; + + /* "src/pyscipopt/scip.pxi":435 + * row = Row() + * row.scip_row = sciprow + * return row # <<<<<<<<<<<<<< + * + * property name: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_row); + __pyx_r = ((PyObject *)__pyx_v_row); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":430 + * + * @staticmethod + * cdef create(SCIP_ROW* sciprow): # <<<<<<<<<<<<<< + * if sciprow == NULL: + * raise Warning("cannot create Row with SCIP_ROW* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Row.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_row); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":438 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * cname = bytes( SCIProwGetName(self.scip_row) ) + * return cname.decode('utf-8') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_v_cname = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "src/pyscipopt/scip.pxi":439 + * property name: + * def __get__(self): + * cname = bytes( SCIProwGetName(self.scip_row) ) # <<<<<<<<<<<<<< + * return cname.decode('utf-8') + * + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIProwGetName(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_cname = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":440 + * def __get__(self): + * cname = bytes( SCIProwGetName(self.scip_row) ) + * return cname.decode('utf-8') # <<<<<<<<<<<<<< + * + * def getLhs(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_decode_bytes(__pyx_v_cname, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":438 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * cname = bytes( SCIProwGetName(self.scip_row) ) + * return cname.decode('utf-8') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Row.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_cname); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":442 + * return cname.decode('utf-8') + * + * def getLhs(self): # <<<<<<<<<<<<<< + * """returns the left hand side of row""" + * return SCIProwGetLhs(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_1getLhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_getLhs, "Row.getLhs(self)\nreturns the left hand side of row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_1getLhs = {"getLhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_1getLhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_getLhs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_1getLhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLhs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLhs", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLhs", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_getLhs(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_getLhs(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLhs", 1); + + /* "src/pyscipopt/scip.pxi":444 + * def getLhs(self): + * """returns the left hand side of row""" + * return SCIProwGetLhs(self.scip_row) # <<<<<<<<<<<<<< + * + * def getRhs(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIProwGetLhs(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":442 + * return cname.decode('utf-8') + * + * def getLhs(self): # <<<<<<<<<<<<<< + * """returns the left hand side of row""" + * return SCIProwGetLhs(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.getLhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":446 + * return SCIProwGetLhs(self.scip_row) + * + * def getRhs(self): # <<<<<<<<<<<<<< + * """returns the right hand side of row""" + * return SCIProwGetRhs(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_3getRhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_2getRhs, "Row.getRhs(self)\nreturns the right hand side of row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_3getRhs = {"getRhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_3getRhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_2getRhs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_3getRhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRhs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getRhs", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRhs", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_2getRhs(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_2getRhs(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRhs", 1); + + /* "src/pyscipopt/scip.pxi":448 + * def getRhs(self): + * """returns the right hand side of row""" + * return SCIProwGetRhs(self.scip_row) # <<<<<<<<<<<<<< + * + * def getConstant(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIProwGetRhs(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":446 + * return SCIProwGetLhs(self.scip_row) + * + * def getRhs(self): # <<<<<<<<<<<<<< + * """returns the right hand side of row""" + * return SCIProwGetRhs(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.getRhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":450 + * return SCIProwGetRhs(self.scip_row) + * + * def getConstant(self): # <<<<<<<<<<<<<< + * """gets constant shift of row""" + * return SCIProwGetConstant(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_5getConstant(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_4getConstant, "Row.getConstant(self)\ngets constant shift of row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_5getConstant = {"getConstant", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_5getConstant, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_4getConstant}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_5getConstant(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getConstant (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getConstant", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConstant", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_4getConstant(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_4getConstant(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getConstant", 1); + + /* "src/pyscipopt/scip.pxi":452 + * def getConstant(self): + * """gets constant shift of row""" + * return SCIProwGetConstant(self.scip_row) # <<<<<<<<<<<<<< + * + * def getLPPos(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIProwGetConstant(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":450 + * return SCIProwGetRhs(self.scip_row) + * + * def getConstant(self): # <<<<<<<<<<<<<< + * """gets constant shift of row""" + * return SCIProwGetConstant(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.getConstant", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":454 + * return SCIProwGetConstant(self.scip_row) + * + * def getLPPos(self): # <<<<<<<<<<<<<< + * """gets position of row in current LP, or -1 if it is not in LP""" + * return SCIProwGetLPPos(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_7getLPPos(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_6getLPPos, "Row.getLPPos(self)\ngets position of row in current LP, or -1 if it is not in LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_7getLPPos = {"getLPPos", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_7getLPPos, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_6getLPPos}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_7getLPPos(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPPos (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPPos", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPPos", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_6getLPPos(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_6getLPPos(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPPos", 1); + + /* "src/pyscipopt/scip.pxi":456 + * def getLPPos(self): + * """gets position of row in current LP, or -1 if it is not in LP""" + * return SCIProwGetLPPos(self.scip_row) # <<<<<<<<<<<<<< + * + * def getBasisStatus(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIProwGetLPPos(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":454 + * return SCIProwGetConstant(self.scip_row) + * + * def getLPPos(self): # <<<<<<<<<<<<<< + * """gets position of row in current LP, or -1 if it is not in LP""" + * return SCIProwGetLPPos(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.getLPPos", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":458 + * return SCIProwGetLPPos(self.scip_row) + * + * def getBasisStatus(self): # <<<<<<<<<<<<<< + * """gets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_9getBasisStatus(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_8getBasisStatus, "Row.getBasisStatus(self)\ngets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_9getBasisStatus = {"getBasisStatus", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_9getBasisStatus, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_8getBasisStatus}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_9getBasisStatus(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBasisStatus (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBasisStatus", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBasisStatus", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_8getBasisStatus(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_8getBasisStatus(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + SCIP_BASESTAT __pyx_v_stat; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBasisStatus", 1); + + /* "src/pyscipopt/scip.pxi":460 + * def getBasisStatus(self): + * """gets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row) # <<<<<<<<<<<<<< + * if stat == SCIP_BASESTAT_LOWER: + * return "lower" + */ + __pyx_v_stat = SCIProwGetBasisStatus(__pyx_v_self->scip_row); + + /* "src/pyscipopt/scip.pxi":461 + * """gets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row) + * if stat == SCIP_BASESTAT_LOWER: # <<<<<<<<<<<<<< + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_BASESTAT_LOWER); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":462 + * cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row) + * if stat == SCIP_BASESTAT_LOWER: + * return "lower" # <<<<<<<<<<<<<< + * elif stat == SCIP_BASESTAT_BASIC: + * return "basic" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_lower); + __pyx_r = __pyx_n_u_lower; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":461 + * """gets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row) + * if stat == SCIP_BASESTAT_LOWER: # <<<<<<<<<<<<<< + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: + */ + } + + /* "src/pyscipopt/scip.pxi":463 + * if stat == SCIP_BASESTAT_LOWER: + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: # <<<<<<<<<<<<<< + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_BASESTAT_BASIC); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":464 + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: + * return "basic" # <<<<<<<<<<<<<< + * elif stat == SCIP_BASESTAT_UPPER: + * return "upper" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_basic); + __pyx_r = __pyx_n_u_basic; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":463 + * if stat == SCIP_BASESTAT_LOWER: + * return "lower" + * elif stat == SCIP_BASESTAT_BASIC: # <<<<<<<<<<<<<< + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: + */ + } + + /* "src/pyscipopt/scip.pxi":465 + * elif stat == SCIP_BASESTAT_BASIC: + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: # <<<<<<<<<<<<<< + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_BASESTAT_UPPER); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":466 + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: + * return "upper" # <<<<<<<<<<<<<< + * elif stat == SCIP_BASESTAT_ZERO: + * # this shouldn't happen! + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_upper); + __pyx_r = __pyx_n_u_upper; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":465 + * elif stat == SCIP_BASESTAT_BASIC: + * return "basic" + * elif stat == SCIP_BASESTAT_UPPER: # <<<<<<<<<<<<<< + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: + */ + } + + /* "src/pyscipopt/scip.pxi":467 + * elif stat == SCIP_BASESTAT_UPPER: + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: # <<<<<<<<<<<<<< + * # this shouldn't happen! + * raise Exception('SCIP returned base status zero for a row!') + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_BASESTAT_ZERO); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":469 + * elif stat == SCIP_BASESTAT_ZERO: + * # this shouldn't happen! + * raise Exception('SCIP returned base status zero for a row!') # <<<<<<<<<<<<<< + * else: + * raise Exception('SCIP returned unknown base status!') + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 469, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":467 + * elif stat == SCIP_BASESTAT_UPPER: + * return "upper" + * elif stat == SCIP_BASESTAT_ZERO: # <<<<<<<<<<<<<< + * # this shouldn't happen! + * raise Exception('SCIP returned base status zero for a row!') + */ + } + + /* "src/pyscipopt/scip.pxi":471 + * raise Exception('SCIP returned base status zero for a row!') + * else: + * raise Exception('SCIP returned unknown base status!') # <<<<<<<<<<<<<< + * + * def isIntegral(self): + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 471, __pyx_L1_error) + } + + /* "src/pyscipopt/scip.pxi":458 + * return SCIProwGetLPPos(self.scip_row) + * + * def getBasisStatus(self): # <<<<<<<<<<<<<< + * """gets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Row.getBasisStatus", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":473 + * raise Exception('SCIP returned unknown base status!') + * + * def isIntegral(self): # <<<<<<<<<<<<<< + * """returns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution """ + * return SCIProwIsIntegral(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_11isIntegral(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_10isIntegral, "Row.isIntegral(self)\nreturns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_11isIntegral = {"isIntegral", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_11isIntegral, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_10isIntegral}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_11isIntegral(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isIntegral (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isIntegral", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isIntegral", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_10isIntegral(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_10isIntegral(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isIntegral", 1); + + /* "src/pyscipopt/scip.pxi":475 + * def isIntegral(self): + * """returns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution """ + * return SCIProwIsIntegral(self.scip_row) # <<<<<<<<<<<<<< + * + * def isLocal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIProwIsIntegral(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":473 + * raise Exception('SCIP returned unknown base status!') + * + * def isIntegral(self): # <<<<<<<<<<<<<< + * """returns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution """ + * return SCIProwIsIntegral(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.isIntegral", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":477 + * return SCIProwIsIntegral(self.scip_row) + * + * def isLocal(self): # <<<<<<<<<<<<<< + * """returns TRUE iff the row is only valid locally """ + * return SCIProwIsLocal(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_13isLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_12isLocal, "Row.isLocal(self)\nreturns TRUE iff the row is only valid locally "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_13isLocal = {"isLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_13isLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_12isLocal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_13isLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isLocal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isLocal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isLocal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_12isLocal(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_12isLocal(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isLocal", 1); + + /* "src/pyscipopt/scip.pxi":479 + * def isLocal(self): + * """returns TRUE iff the row is only valid locally """ + * return SCIProwIsLocal(self.scip_row) # <<<<<<<<<<<<<< + * + * def isModifiable(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIProwIsLocal(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":477 + * return SCIProwIsIntegral(self.scip_row) + * + * def isLocal(self): # <<<<<<<<<<<<<< + * """returns TRUE iff the row is only valid locally """ + * return SCIProwIsLocal(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.isLocal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":481 + * return SCIProwIsLocal(self.scip_row) + * + * def isModifiable(self): # <<<<<<<<<<<<<< + * """returns TRUE iff row is modifiable during node processing (subject to column generation) """ + * return SCIProwIsModifiable(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_15isModifiable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_14isModifiable, "Row.isModifiable(self)\nreturns TRUE iff row is modifiable during node processing (subject to column generation) "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_15isModifiable = {"isModifiable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_15isModifiable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_14isModifiable}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_15isModifiable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isModifiable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isModifiable", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isModifiable", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_14isModifiable(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_14isModifiable(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isModifiable", 1); + + /* "src/pyscipopt/scip.pxi":483 + * def isModifiable(self): + * """returns TRUE iff row is modifiable during node processing (subject to column generation) """ + * return SCIProwIsModifiable(self.scip_row) # <<<<<<<<<<<<<< + * + * def isRemovable(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIProwIsModifiable(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 483, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":481 + * return SCIProwIsLocal(self.scip_row) + * + * def isModifiable(self): # <<<<<<<<<<<<<< + * """returns TRUE iff row is modifiable during node processing (subject to column generation) """ + * return SCIProwIsModifiable(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.isModifiable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":485 + * return SCIProwIsModifiable(self.scip_row) + * + * def isRemovable(self): # <<<<<<<<<<<<<< + * """returns TRUE iff row is removable from the LP (due to aging or cleanup)""" + * return SCIProwIsRemovable(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_17isRemovable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_16isRemovable, "Row.isRemovable(self)\nreturns TRUE iff row is removable from the LP (due to aging or cleanup)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_17isRemovable = {"isRemovable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_17isRemovable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_16isRemovable}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_17isRemovable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isRemovable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isRemovable", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isRemovable", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_16isRemovable(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_16isRemovable(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isRemovable", 1); + + /* "src/pyscipopt/scip.pxi":487 + * def isRemovable(self): + * """returns TRUE iff row is removable from the LP (due to aging or cleanup)""" + * return SCIProwIsRemovable(self.scip_row) # <<<<<<<<<<<<<< + * + * def isInGlobalCutpool(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIProwIsRemovable(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":485 + * return SCIProwIsModifiable(self.scip_row) + * + * def isRemovable(self): # <<<<<<<<<<<<<< + * """returns TRUE iff row is removable from the LP (due to aging or cleanup)""" + * return SCIProwIsRemovable(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.isRemovable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":489 + * return SCIProwIsRemovable(self.scip_row) + * + * def isInGlobalCutpool(self): # <<<<<<<<<<<<<< + * """return TRUE iff row is a member of the global cut pool""" + * return SCIProwIsInGlobalCutpool(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_19isInGlobalCutpool(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_18isInGlobalCutpool, "Row.isInGlobalCutpool(self)\nreturn TRUE iff row is a member of the global cut pool"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_19isInGlobalCutpool = {"isInGlobalCutpool", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_19isInGlobalCutpool, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_18isInGlobalCutpool}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_19isInGlobalCutpool(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isInGlobalCutpool (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isInGlobalCutpool", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isInGlobalCutpool", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_18isInGlobalCutpool(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_18isInGlobalCutpool(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isInGlobalCutpool", 1); + + /* "src/pyscipopt/scip.pxi":491 + * def isInGlobalCutpool(self): + * """return TRUE iff row is a member of the global cut pool""" + * return SCIProwIsInGlobalCutpool(self.scip_row) # <<<<<<<<<<<<<< + * + * def getOrigintype(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIProwIsInGlobalCutpool(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":489 + * return SCIProwIsRemovable(self.scip_row) + * + * def isInGlobalCutpool(self): # <<<<<<<<<<<<<< + * """return TRUE iff row is a member of the global cut pool""" + * return SCIProwIsInGlobalCutpool(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.isInGlobalCutpool", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":493 + * return SCIProwIsInGlobalCutpool(self.scip_row) + * + * def getOrigintype(self): # <<<<<<<<<<<<<< + * """returns type of origin that created the row""" + * return SCIProwGetOrigintype(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_21getOrigintype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_20getOrigintype, "Row.getOrigintype(self)\nreturns type of origin that created the row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_21getOrigintype = {"getOrigintype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_21getOrigintype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_20getOrigintype}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_21getOrigintype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getOrigintype (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getOrigintype", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOrigintype", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_20getOrigintype(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_20getOrigintype(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getOrigintype", 1); + + /* "src/pyscipopt/scip.pxi":495 + * def getOrigintype(self): + * """returns type of origin that created the row""" + * return SCIProwGetOrigintype(self.scip_row) # <<<<<<<<<<<<<< + * + * def getConsOriginConshdlrtype(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_ROWORIGINTYPE(SCIProwGetOrigintype(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":493 + * return SCIProwIsInGlobalCutpool(self.scip_row) + * + * def getOrigintype(self): # <<<<<<<<<<<<<< + * """returns type of origin that created the row""" + * return SCIProwGetOrigintype(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.getOrigintype", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":497 + * return SCIProwGetOrigintype(self.scip_row) + * + * def getConsOriginConshdlrtype(self): # <<<<<<<<<<<<<< + * """returns type of constraint handler that created the row""" + * cdef SCIP_CONS* scip_con = SCIProwGetOriginCons(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_23getConsOriginConshdlrtype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_22getConsOriginConshdlrtype, "Row.getConsOriginConshdlrtype(self)\nreturns type of constraint handler that created the row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_23getConsOriginConshdlrtype = {"getConsOriginConshdlrtype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_23getConsOriginConshdlrtype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_22getConsOriginConshdlrtype}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_23getConsOriginConshdlrtype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getConsOriginConshdlrtype (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getConsOriginConshdlrtype", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConsOriginConshdlrtype", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_22getConsOriginConshdlrtype(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_22getConsOriginConshdlrtype(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + SCIP_CONS *__pyx_v_scip_con; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getConsOriginConshdlrtype", 1); + + /* "src/pyscipopt/scip.pxi":499 + * def getConsOriginConshdlrtype(self): + * """returns type of constraint handler that created the row""" + * cdef SCIP_CONS* scip_con = SCIProwGetOriginCons(self.scip_row) # <<<<<<<<<<<<<< + * return bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(scip_con))).decode('UTF-8') + * + */ + __pyx_v_scip_con = SCIProwGetOriginCons(__pyx_v_self->scip_row); + + /* "src/pyscipopt/scip.pxi":500 + * """returns type of constraint handler that created the row""" + * cdef SCIP_CONS* scip_con = SCIProwGetOriginCons(self.scip_row) + * return bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(scip_con))).decode('UTF-8') # <<<<<<<<<<<<<< + * + * def getNNonz(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_scip_con))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":497 + * return SCIProwGetOrigintype(self.scip_row) + * + * def getConsOriginConshdlrtype(self): # <<<<<<<<<<<<<< + * """returns type of constraint handler that created the row""" + * cdef SCIP_CONS* scip_con = SCIProwGetOriginCons(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Row.getConsOriginConshdlrtype", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":502 + * return bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(scip_con))).decode('UTF-8') + * + * def getNNonz(self): # <<<<<<<<<<<<<< + * """get number of nonzero entries in row vector""" + * return SCIProwGetNNonz(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_25getNNonz(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_24getNNonz, "Row.getNNonz(self)\nget number of nonzero entries in row vector"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_25getNNonz = {"getNNonz", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_25getNNonz, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_24getNNonz}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_25getNNonz(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNNonz (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNNonz", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNNonz", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_24getNNonz(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_24getNNonz(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNNonz", 1); + + /* "src/pyscipopt/scip.pxi":504 + * def getNNonz(self): + * """get number of nonzero entries in row vector""" + * return SCIProwGetNNonz(self.scip_row) # <<<<<<<<<<<<<< + * + * def getNLPNonz(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIProwGetNNonz(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":502 + * return bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(scip_con))).decode('UTF-8') + * + * def getNNonz(self): # <<<<<<<<<<<<<< + * """get number of nonzero entries in row vector""" + * return SCIProwGetNNonz(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.getNNonz", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":506 + * return SCIProwGetNNonz(self.scip_row) + * + * def getNLPNonz(self): # <<<<<<<<<<<<<< + * """get number of nonzero entries in row vector that correspond to columns currently in the SCIP LP""" + * return SCIProwGetNLPNonz(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_27getNLPNonz(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_26getNLPNonz, "Row.getNLPNonz(self)\nget number of nonzero entries in row vector that correspond to columns currently in the SCIP LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_27getNLPNonz = {"getNLPNonz", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_27getNLPNonz, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_26getNLPNonz}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_27getNLPNonz(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNLPNonz (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNLPNonz", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLPNonz", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_26getNLPNonz(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_26getNLPNonz(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNLPNonz", 1); + + /* "src/pyscipopt/scip.pxi":508 + * def getNLPNonz(self): + * """get number of nonzero entries in row vector that correspond to columns currently in the SCIP LP""" + * return SCIProwGetNLPNonz(self.scip_row) # <<<<<<<<<<<<<< + * + * def getCols(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIProwGetNLPNonz(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":506 + * return SCIProwGetNNonz(self.scip_row) + * + * def getNLPNonz(self): # <<<<<<<<<<<<<< + * """get number of nonzero entries in row vector that correspond to columns currently in the SCIP LP""" + * return SCIProwGetNLPNonz(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.getNLPNonz", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":510 + * return SCIProwGetNLPNonz(self.scip_row) + * + * def getCols(self): # <<<<<<<<<<<<<< + * """gets list with columns of nonzero entries""" + * cdef SCIP_COL** cols = SCIProwGetCols(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_29getCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_28getCols, "Row.getCols(self)\ngets list with columns of nonzero entries"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_29getCols = {"getCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_29getCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_28getCols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_29getCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getCols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getCols", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCols", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_28getCols(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_28getCols(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + SCIP_COL **__pyx_v_cols; + PyObject *__pyx_9genexpr17__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getCols", 1); + + /* "src/pyscipopt/scip.pxi":512 + * def getCols(self): + * """gets list with columns of nonzero entries""" + * cdef SCIP_COL** cols = SCIProwGetCols(self.scip_row) # <<<<<<<<<<<<<< + * return [Column.create(cols[i]) for i in range(self.getNNonz())] + * + */ + __pyx_v_cols = SCIProwGetCols(__pyx_v_self->scip_row); + + /* "src/pyscipopt/scip.pxi":513 + * """gets list with columns of nonzero entries""" + * cdef SCIP_COL** cols = SCIProwGetCols(self.scip_row) + * return [Column.create(cols[i]) for i in range(self.getNNonz())] # <<<<<<<<<<<<<< + * + * def getVals(self): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getNNonz); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 513, __pyx_L5_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 513, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 513, __pyx_L5_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 513, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 513, __pyx_L5_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_7(__pyx_t_2); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 513, __pyx_L5_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_9genexpr17__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyIndex_AsSsize_t(__pyx_9genexpr17__pyx_v_i); if (unlikely((__pyx_t_8 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 513, __pyx_L5_error) + __pyx_t_3 = __pyx_f_9pyscipopt_4scip_6Column_create((__pyx_v_cols[__pyx_t_8])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 513, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_9genexpr17__pyx_v_i); __pyx_9genexpr17__pyx_v_i = 0; + goto __pyx_L9_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_9genexpr17__pyx_v_i); __pyx_9genexpr17__pyx_v_i = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":510 + * return SCIProwGetNLPNonz(self.scip_row) + * + * def getCols(self): # <<<<<<<<<<<<<< + * """gets list with columns of nonzero entries""" + * cdef SCIP_COL** cols = SCIProwGetCols(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Row.getCols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_9genexpr17__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":515 + * return [Column.create(cols[i]) for i in range(self.getNNonz())] + * + * def getVals(self): # <<<<<<<<<<<<<< + * """gets list with coefficients of nonzero entries""" + * cdef SCIP_Real* vals = SCIProwGetVals(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_31getVals(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_30getVals, "Row.getVals(self)\ngets list with coefficients of nonzero entries"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_31getVals = {"getVals", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_31getVals, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_30getVals}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_31getVals(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVals (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getVals", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getVals", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_30getVals(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_30getVals(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + SCIP_Real *__pyx_v_vals; + PyObject *__pyx_9genexpr18__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVals", 1); + + /* "src/pyscipopt/scip.pxi":517 + * def getVals(self): + * """gets list with coefficients of nonzero entries""" + * cdef SCIP_Real* vals = SCIProwGetVals(self.scip_row) # <<<<<<<<<<<<<< + * return [vals[i] for i in range(self.getNNonz())] + * + */ + __pyx_v_vals = SCIProwGetVals(__pyx_v_self->scip_row); + + /* "src/pyscipopt/scip.pxi":518 + * """gets list with coefficients of nonzero entries""" + * cdef SCIP_Real* vals = SCIProwGetVals(self.scip_row) + * return [vals[i] for i in range(self.getNNonz())] # <<<<<<<<<<<<<< + * + * def getNorm(self): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getNNonz); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 518, __pyx_L5_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 518, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 518, __pyx_L5_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 518, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 518, __pyx_L5_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_7(__pyx_t_2); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 518, __pyx_L5_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_9genexpr18__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyIndex_AsSsize_t(__pyx_9genexpr18__pyx_v_i); if (unlikely((__pyx_t_8 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 518, __pyx_L5_error) + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_vals[__pyx_t_8])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 518, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_9genexpr18__pyx_v_i); __pyx_9genexpr18__pyx_v_i = 0; + goto __pyx_L9_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_9genexpr18__pyx_v_i); __pyx_9genexpr18__pyx_v_i = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":515 + * return [Column.create(cols[i]) for i in range(self.getNNonz())] + * + * def getVals(self): # <<<<<<<<<<<<<< + * """gets list with coefficients of nonzero entries""" + * cdef SCIP_Real* vals = SCIProwGetVals(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Row.getVals", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_9genexpr18__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":520 + * return [vals[i] for i in range(self.getNNonz())] + * + * def getNorm(self): # <<<<<<<<<<<<<< + * """gets Euclidean norm of row vector """ + * return SCIProwGetNorm(self.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_33getNorm(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_32getNorm, "Row.getNorm(self)\ngets Euclidean norm of row vector "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_33getNorm = {"getNorm", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_33getNorm, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_32getNorm}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_33getNorm(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNorm (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNorm", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNorm", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_32getNorm(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_32getNorm(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNorm", 1); + + /* "src/pyscipopt/scip.pxi":522 + * def getNorm(self): + * """gets Euclidean norm of row vector """ + * return SCIProwGetNorm(self.scip_row) # <<<<<<<<<<<<<< + * + * def __hash__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIProwGetNorm(__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":520 + * return [vals[i] for i in range(self.getNNonz())] + * + * def getNorm(self): # <<<<<<<<<<<<<< + * """gets Euclidean norm of row vector """ + * return SCIProwGetNorm(self.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.getNorm", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":524 + * return SCIProwGetNorm(self.scip_row) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_row) + * + */ + +/* Python wrapper */ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_3Row_35__hash__(PyObject *__pyx_v_self); /*proto*/ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_3Row_35__hash__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_34__hash__(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_hash_t __pyx_pf_9pyscipopt_4scip_3Row_34__hash__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_hash_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__hash__", 1); + + /* "src/pyscipopt/scip.pxi":525 + * + * def __hash__(self): + * return hash(self.scip_row) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 525, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":524 + * return SCIProwGetNorm(self.scip_row) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_row) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Row.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":527 + * return hash(self.scip_row) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_row == (other).scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_37__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_37__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_36__eq__(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_36__eq__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "src/pyscipopt/scip.pxi":528 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_row == (other).scip_row) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "src/pyscipopt/scip.pxi":529 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_row == (other).scip_row) # <<<<<<<<<<<<<< + * + * cdef class NLRow: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":528 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_row == (other).scip_row) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 528, __pyx_L1_error) + if (__pyx_t_5) { + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "src/pyscipopt/scip.pxi":529 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_row == (other).scip_row) # <<<<<<<<<<<<<< + * + * cdef class NLRow: + */ + __pyx_t_5 = (__pyx_v_self->scip_row == ((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_other)->scip_row); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":527 + * return hash(self.scip_row) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_row == (other).scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Row.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1887 + * cdef SCIP_ROW* scip_row + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * + * @staticmethod + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_3Row_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_3Row_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_3Row_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_3Row_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_3Row_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_3Row_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_39__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_38__reduce_cython__, "Row.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_39__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_39__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_38__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_39__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_38__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_38__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_row_cannot_be_converte, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Row.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_41__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_3Row_40__setstate_cython__, "Row.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_3Row_41__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_41__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_40__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_3Row_41__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Row.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_3Row_40__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Row *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_3Row_40__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_row_cannot_be_converte, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Row.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":535 + * + * @staticmethod + * cdef create(SCIP_NLROW* scipnlrow): # <<<<<<<<<<<<<< + * if scipnlrow == NULL: + * raise Warning("cannot create NLRow with SCIP_NLROW* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_5NLRow_create(SCIP_NLROW *__pyx_v_scipnlrow) { + struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":536 + * @staticmethod + * cdef create(SCIP_NLROW* scipnlrow): + * if scipnlrow == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create NLRow with SCIP_NLROW* == NULL") + * nlrow = NLRow() + */ + __pyx_t_1 = (__pyx_v_scipnlrow == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":537 + * cdef create(SCIP_NLROW* scipnlrow): + * if scipnlrow == NULL: + * raise Warning("cannot create NLRow with SCIP_NLROW* == NULL") # <<<<<<<<<<<<<< + * nlrow = NLRow() + * nlrow.scip_nlrow = scipnlrow + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 537, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":536 + * @staticmethod + * cdef create(SCIP_NLROW* scipnlrow): + * if scipnlrow == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create NLRow with SCIP_NLROW* == NULL") + * nlrow = NLRow() + */ + } + + /* "src/pyscipopt/scip.pxi":538 + * if scipnlrow == NULL: + * raise Warning("cannot create NLRow with SCIP_NLROW* == NULL") + * nlrow = NLRow() # <<<<<<<<<<<<<< + * nlrow.scip_nlrow = scipnlrow + * return nlrow + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_NLRow)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_nlrow = ((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":539 + * raise Warning("cannot create NLRow with SCIP_NLROW* == NULL") + * nlrow = NLRow() + * nlrow.scip_nlrow = scipnlrow # <<<<<<<<<<<<<< + * return nlrow + * + */ + __pyx_v_nlrow->scip_nlrow = __pyx_v_scipnlrow; + + /* "src/pyscipopt/scip.pxi":540 + * nlrow = NLRow() + * nlrow.scip_nlrow = scipnlrow + * return nlrow # <<<<<<<<<<<<<< + * + * property name: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_nlrow); + __pyx_r = ((PyObject *)__pyx_v_nlrow); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":535 + * + * @staticmethod + * cdef create(SCIP_NLROW* scipnlrow): # <<<<<<<<<<<<<< + * if scipnlrow == NULL: + * raise Warning("cannot create NLRow with SCIP_NLROW* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_nlrow); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":543 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * cname = bytes( SCIPnlrowGetName(self.scip_nlrow) ) + * return cname.decode('utf-8') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_4name___get__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + PyObject *__pyx_v_cname = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "src/pyscipopt/scip.pxi":544 + * property name: + * def __get__(self): + * cname = bytes( SCIPnlrowGetName(self.scip_nlrow) ) # <<<<<<<<<<<<<< + * return cname.decode('utf-8') + * + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPnlrowGetName(__pyx_v_self->scip_nlrow)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_cname = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":545 + * def __get__(self): + * cname = bytes( SCIPnlrowGetName(self.scip_nlrow) ) + * return cname.decode('utf-8') # <<<<<<<<<<<<<< + * + * def getConstant(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_decode_bytes(__pyx_v_cname, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":543 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * cname = bytes( SCIPnlrowGetName(self.scip_nlrow) ) + * return cname.decode('utf-8') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_cname); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":547 + * return cname.decode('utf-8') + * + * def getConstant(self): # <<<<<<<<<<<<<< + * """returns the constant of a nonlinear row""" + * return SCIPnlrowGetConstant(self.scip_nlrow) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_1getConstant(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5NLRow_getConstant, "NLRow.getConstant(self)\nreturns the constant of a nonlinear row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5NLRow_1getConstant = {"getConstant", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_1getConstant, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_getConstant}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_1getConstant(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getConstant (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getConstant", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConstant", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_getConstant(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_getConstant(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getConstant", 1); + + /* "src/pyscipopt/scip.pxi":549 + * def getConstant(self): + * """returns the constant of a nonlinear row""" + * return SCIPnlrowGetConstant(self.scip_nlrow) # <<<<<<<<<<<<<< + * + * def getLinearTerms(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPnlrowGetConstant(__pyx_v_self->scip_nlrow)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":547 + * return cname.decode('utf-8') + * + * def getConstant(self): # <<<<<<<<<<<<<< + * """returns the constant of a nonlinear row""" + * return SCIPnlrowGetConstant(self.scip_nlrow) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.getConstant", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":551 + * return SCIPnlrowGetConstant(self.scip_nlrow) + * + * def getLinearTerms(self): # <<<<<<<<<<<<<< + * """returns a list of tuples (var, coef) representing the linear part of a nonlinear row""" + * cdef SCIP_VAR** linvars = SCIPnlrowGetLinearVars(self.scip_nlrow) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_3getLinearTerms(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5NLRow_2getLinearTerms, "NLRow.getLinearTerms(self)\nreturns a list of tuples (var, coef) representing the linear part of a nonlinear row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5NLRow_3getLinearTerms = {"getLinearTerms", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_3getLinearTerms, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_2getLinearTerms}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_3getLinearTerms(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLinearTerms (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLinearTerms", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLinearTerms", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_2getLinearTerms(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_2getLinearTerms(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + SCIP_VAR **__pyx_v_linvars; + SCIP_Real *__pyx_v_lincoefs; + int __pyx_v_nlinvars; + int __pyx_9genexpr19__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLinearTerms", 1); + + /* "src/pyscipopt/scip.pxi":553 + * def getLinearTerms(self): + * """returns a list of tuples (var, coef) representing the linear part of a nonlinear row""" + * cdef SCIP_VAR** linvars = SCIPnlrowGetLinearVars(self.scip_nlrow) # <<<<<<<<<<<<<< + * cdef SCIP_Real* lincoefs = SCIPnlrowGetLinearCoefs(self.scip_nlrow) + * cdef int nlinvars = SCIPnlrowGetNLinearVars(self.scip_nlrow) + */ + __pyx_v_linvars = SCIPnlrowGetLinearVars(__pyx_v_self->scip_nlrow); + + /* "src/pyscipopt/scip.pxi":554 + * """returns a list of tuples (var, coef) representing the linear part of a nonlinear row""" + * cdef SCIP_VAR** linvars = SCIPnlrowGetLinearVars(self.scip_nlrow) + * cdef SCIP_Real* lincoefs = SCIPnlrowGetLinearCoefs(self.scip_nlrow) # <<<<<<<<<<<<<< + * cdef int nlinvars = SCIPnlrowGetNLinearVars(self.scip_nlrow) + * return [(Variable.create(linvars[i]), lincoefs[i]) for i in range(nlinvars)] + */ + __pyx_v_lincoefs = SCIPnlrowGetLinearCoefs(__pyx_v_self->scip_nlrow); + + /* "src/pyscipopt/scip.pxi":555 + * cdef SCIP_VAR** linvars = SCIPnlrowGetLinearVars(self.scip_nlrow) + * cdef SCIP_Real* lincoefs = SCIPnlrowGetLinearCoefs(self.scip_nlrow) + * cdef int nlinvars = SCIPnlrowGetNLinearVars(self.scip_nlrow) # <<<<<<<<<<<<<< + * return [(Variable.create(linvars[i]), lincoefs[i]) for i in range(nlinvars)] + * + */ + __pyx_v_nlinvars = SCIPnlrowGetNLinearVars(__pyx_v_self->scip_nlrow); + + /* "src/pyscipopt/scip.pxi":556 + * cdef SCIP_Real* lincoefs = SCIPnlrowGetLinearCoefs(self.scip_nlrow) + * cdef int nlinvars = SCIPnlrowGetNLinearVars(self.scip_nlrow) + * return [(Variable.create(linvars[i]), lincoefs[i]) for i in range(nlinvars)] # <<<<<<<<<<<<<< + * + * def getLhs(self): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_v_nlinvars; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_9genexpr19__pyx_v_i = __pyx_t_4; + __pyx_t_5 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_linvars[__pyx_9genexpr19__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyFloat_FromDouble((__pyx_v_lincoefs[__pyx_9genexpr19__pyx_v_i])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5)) __PYX_ERR(0, 556, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6)) __PYX_ERR(0, 556, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":551 + * return SCIPnlrowGetConstant(self.scip_nlrow) + * + * def getLinearTerms(self): # <<<<<<<<<<<<<< + * """returns a list of tuples (var, coef) representing the linear part of a nonlinear row""" + * cdef SCIP_VAR** linvars = SCIPnlrowGetLinearVars(self.scip_nlrow) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.getLinearTerms", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":558 + * return [(Variable.create(linvars[i]), lincoefs[i]) for i in range(nlinvars)] + * + * def getLhs(self): # <<<<<<<<<<<<<< + * """returns the left hand side of a nonlinear row""" + * return SCIPnlrowGetLhs(self.scip_nlrow) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_5getLhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5NLRow_4getLhs, "NLRow.getLhs(self)\nreturns the left hand side of a nonlinear row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5NLRow_5getLhs = {"getLhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_5getLhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_4getLhs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_5getLhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLhs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLhs", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLhs", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_4getLhs(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_4getLhs(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLhs", 1); + + /* "src/pyscipopt/scip.pxi":560 + * def getLhs(self): + * """returns the left hand side of a nonlinear row""" + * return SCIPnlrowGetLhs(self.scip_nlrow) # <<<<<<<<<<<<<< + * + * def getRhs(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPnlrowGetLhs(__pyx_v_self->scip_nlrow)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":558 + * return [(Variable.create(linvars[i]), lincoefs[i]) for i in range(nlinvars)] + * + * def getLhs(self): # <<<<<<<<<<<<<< + * """returns the left hand side of a nonlinear row""" + * return SCIPnlrowGetLhs(self.scip_nlrow) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.getLhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":562 + * return SCIPnlrowGetLhs(self.scip_nlrow) + * + * def getRhs(self): # <<<<<<<<<<<<<< + * """returns the right hand side of a nonlinear row""" + * return SCIPnlrowGetRhs(self.scip_nlrow) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_7getRhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5NLRow_6getRhs, "NLRow.getRhs(self)\nreturns the right hand side of a nonlinear row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5NLRow_7getRhs = {"getRhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_7getRhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_6getRhs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_7getRhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRhs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getRhs", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getRhs", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_6getRhs(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_6getRhs(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRhs", 1); + + /* "src/pyscipopt/scip.pxi":564 + * def getRhs(self): + * """returns the right hand side of a nonlinear row""" + * return SCIPnlrowGetRhs(self.scip_nlrow) # <<<<<<<<<<<<<< + * + * def getDualsol(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPnlrowGetRhs(__pyx_v_self->scip_nlrow)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 564, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":562 + * return SCIPnlrowGetLhs(self.scip_nlrow) + * + * def getRhs(self): # <<<<<<<<<<<<<< + * """returns the right hand side of a nonlinear row""" + * return SCIPnlrowGetRhs(self.scip_nlrow) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.getRhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":566 + * return SCIPnlrowGetRhs(self.scip_nlrow) + * + * def getDualsol(self): # <<<<<<<<<<<<<< + * """gets the dual NLP solution of a nonlinear row""" + * return SCIPnlrowGetDualsol(self.scip_nlrow) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_9getDualsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5NLRow_8getDualsol, "NLRow.getDualsol(self)\ngets the dual NLP solution of a nonlinear row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5NLRow_9getDualsol = {"getDualsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_9getDualsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_8getDualsol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_9getDualsol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDualsol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getDualsol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDualsol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_8getDualsol(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_8getDualsol(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDualsol", 1); + + /* "src/pyscipopt/scip.pxi":568 + * def getDualsol(self): + * """gets the dual NLP solution of a nonlinear row""" + * return SCIPnlrowGetDualsol(self.scip_nlrow) # <<<<<<<<<<<<<< + * + * def __hash__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPnlrowGetDualsol(__pyx_v_self->scip_nlrow)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":566 + * return SCIPnlrowGetRhs(self.scip_nlrow) + * + * def getDualsol(self): # <<<<<<<<<<<<<< + * """gets the dual NLP solution of a nonlinear row""" + * return SCIPnlrowGetDualsol(self.scip_nlrow) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.getDualsol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":570 + * return SCIPnlrowGetDualsol(self.scip_nlrow) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_nlrow) + * + */ + +/* Python wrapper */ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_5NLRow_11__hash__(PyObject *__pyx_v_self); /*proto*/ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_5NLRow_11__hash__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_10__hash__(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_hash_t __pyx_pf_9pyscipopt_4scip_5NLRow_10__hash__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_hash_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__hash__", 1); + + /* "src/pyscipopt/scip.pxi":571 + * + * def __hash__(self): + * return hash(self.scip_nlrow) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->scip_nlrow)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 571, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 571, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":570 + * return SCIPnlrowGetDualsol(self.scip_nlrow) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_nlrow) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":573 + * return hash(self.scip_nlrow) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_nlrow == (other).scip_nlrow) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_13__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_13__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_12__eq__(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_12__eq__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "src/pyscipopt/scip.pxi":574 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_nlrow == (other).scip_nlrow) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "src/pyscipopt/scip.pxi":575 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_nlrow == (other).scip_nlrow) # <<<<<<<<<<<<<< + * + * cdef class Solution: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":574 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_nlrow == (other).scip_nlrow) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 574, __pyx_L1_error) + if (__pyx_t_5) { + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "src/pyscipopt/scip.pxi":575 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_nlrow == (other).scip_nlrow) # <<<<<<<<<<<<<< + * + * cdef class Solution: + */ + __pyx_t_5 = (__pyx_v_self->scip_nlrow == ((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_other)->scip_nlrow); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":573 + * return hash(self.scip_nlrow) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_nlrow == (other).scip_nlrow) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.NLRow.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1895 + * cdef SCIP_NLROW* scip_nlrow + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * + * @staticmethod + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_4data___get__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5NLRow_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5NLRow_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5NLRow_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5NLRow_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5NLRow_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5NLRow_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5NLRow_14__reduce_cython__, "NLRow.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5NLRow_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_14__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_14__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_nlrow_cannot_be_conver, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.NLRow.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5NLRow_16__setstate_cython__, "NLRow.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5NLRow_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_16__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5NLRow_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.NLRow.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5NLRow_16__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_NLRow *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5NLRow_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_nlrow_cannot_be_conver, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.NLRow.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":581 + * + * # We are raising an error here to avoid creating a solution without an associated model. See Issue #625 + * def __init__(self, raise_error = False): # <<<<<<<<<<<<<< + * if not raise_error: + * raise ValueError("To create a solution you should use the createSol method of the Model class.") + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Solution_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Solution_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_raise_error = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_raise_error,0}; + values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_raise_error); + if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 581, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 581, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_raise_error = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 581, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Solution.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution___init__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self), __pyx_v_raise_error); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Solution___init__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, PyObject *__pyx_v_raise_error) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/scip.pxi":582 + * # We are raising an error here to avoid creating a solution without an associated model. See Issue #625 + * def __init__(self, raise_error = False): + * if not raise_error: # <<<<<<<<<<<<<< + * raise ValueError("To create a solution you should use the createSol method of the Model class.") + * + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_raise_error); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 582, __pyx_L1_error) + __pyx_t_2 = (!__pyx_t_1); + if (unlikely(__pyx_t_2)) { + + /* "src/pyscipopt/scip.pxi":583 + * def __init__(self, raise_error = False): + * if not raise_error: + * raise ValueError("To create a solution you should use the createSol method of the Model class.") # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 583, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":582 + * # We are raising an error here to avoid creating a solution without an associated model. See Issue #625 + * def __init__(self, raise_error = False): + * if not raise_error: # <<<<<<<<<<<<<< + * raise ValueError("To create a solution you should use the createSol method of the Model class.") + * + */ + } + + /* "src/pyscipopt/scip.pxi":581 + * + * # We are raising an error here to avoid creating a solution without an associated model. See Issue #625 + * def __init__(self, raise_error = False): # <<<<<<<<<<<<<< + * if not raise_error: + * raise ValueError("To create a solution you should use the createSol method of the Model class.") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Solution.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":586 + * + * @staticmethod + * cdef create(SCIP* scip, SCIP_SOL* scip_sol): # <<<<<<<<<<<<<< + * if scip == NULL: + * raise Warning("cannot create Solution with SCIP* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_8Solution_create(SCIP *__pyx_v_scip, SCIP_SOL *__pyx_v_scip_sol) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":587 + * @staticmethod + * cdef create(SCIP* scip, SCIP_SOL* scip_sol): + * if scip == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Solution with SCIP* == NULL") + * sol = Solution(True) + */ + __pyx_t_1 = (__pyx_v_scip == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":588 + * cdef create(SCIP* scip, SCIP_SOL* scip_sol): + * if scip == NULL: + * raise Warning("cannot create Solution with SCIP* == NULL") # <<<<<<<<<<<<<< + * sol = Solution(True) + * sol.sol = scip_sol + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 588, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":587 + * @staticmethod + * cdef create(SCIP* scip, SCIP_SOL* scip_sol): + * if scip == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Solution with SCIP* == NULL") + * sol = Solution(True) + */ + } + + /* "src/pyscipopt/scip.pxi":589 + * if scip == NULL: + * raise Warning("cannot create Solution with SCIP* == NULL") + * sol = Solution(True) # <<<<<<<<<<<<<< + * sol.sol = scip_sol + * sol.scip = scip + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Solution), __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":590 + * raise Warning("cannot create Solution with SCIP* == NULL") + * sol = Solution(True) + * sol.sol = scip_sol # <<<<<<<<<<<<<< + * sol.scip = scip + * return sol + */ + __pyx_v_sol->sol = __pyx_v_scip_sol; + + /* "src/pyscipopt/scip.pxi":591 + * sol = Solution(True) + * sol.sol = scip_sol + * sol.scip = scip # <<<<<<<<<<<<<< + * return sol + * + */ + __pyx_v_sol->scip = __pyx_v_scip; + + /* "src/pyscipopt/scip.pxi":592 + * sol.sol = scip_sol + * sol.scip = scip + * return sol # <<<<<<<<<<<<<< + * + * def __getitem__(self, Expr expr): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_sol); + __pyx_r = ((PyObject *)__pyx_v_sol); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":586 + * + * @staticmethod + * cdef create(SCIP* scip, SCIP_SOL* scip_sol): # <<<<<<<<<<<<<< + * if scip == NULL: + * raise Warning("cannot create Solution with SCIP* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Solution.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_sol); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":594 + * return sol + * + * def __getitem__(self, Expr expr): # <<<<<<<<<<<<<< + * # fast track for Variable + * if isinstance(expr, Variable): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_expr); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_expr) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_expr), __pyx_ptype_9pyscipopt_4scip_Expr, 1, "expr", 0))) __PYX_ERR(0, 594, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_2__getitem__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self), ((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v_expr)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_9pyscipopt_4scip_8Solution_11__getitem___2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "src/pyscipopt/scip.pxi":600 + * var = expr + * return SCIPgetSolVal(self.scip, self.sol, var.scip_var) + * return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0) # <<<<<<<<<<<<<< + * + * def _evaluate(self, term): + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_11__getitem___genexpr(PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_5_genexpr(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 600, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *) __pyx_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_outer_scope); + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_9pyscipopt_4scip_8Solution_11__getitem___2generator4, NULL, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_getitem___locals_genexpr, __pyx_n_s_pyscipopt_scip); if (unlikely(!gen)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Solution.__getitem__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_9pyscipopt_4scip_8Solution_11__getitem___2generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *__pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L7_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 600, __pyx_L1_error) + __pyx_t_2 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 600, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 600, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_cur_scope->__pyx_genexpr_arg_0, 0, __pyx_n_s_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4); + if (unlikely(__pyx_t_7 == 0)) break; + if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_term); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_term, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_coeff); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_coeff, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_8 = (__Pyx_PyInt_BoolNeObjC(__pyx_cur_scope->__pyx_v_coeff, __pyx_int_0, 0, 0)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 600, __pyx_L1_error) + if (__pyx_t_8) { + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(0, 600, __pyx_L1_error) } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_outer_scope->__pyx_v_self), __pyx_n_s_evaluate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_cur_scope->__pyx_v_term}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = PyNumber_Multiply(__pyx_t_6, __pyx_cur_scope->__pyx_v_coeff); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; + __pyx_cur_scope->__pyx_t_3 = __pyx_t_4; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L7_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; + __pyx_t_4 = __pyx_cur_scope->__pyx_t_3; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 600, __pyx_L1_error) + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + PyErr_SetNone(PyExc_StopIteration); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF(__pyx_r); __pyx_r = 0; + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":594 + * return sol + * + * def __getitem__(self, Expr expr): # <<<<<<<<<<<<<< + * # fast track for Variable + * if isinstance(expr, Variable): + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_2__getitem__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_expr) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *__pyx_cur_scope; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + PyObject *__pyx_gb_9pyscipopt_4scip_8Solution_11__getitem___2generator4 = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + __pyx_cur_scope = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_4___getitem__(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 594, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_v_self = __pyx_v_self; + __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self); + + /* "src/pyscipopt/scip.pxi":596 + * def __getitem__(self, Expr expr): + * # fast track for Variable + * if isinstance(expr, Variable): # <<<<<<<<<<<<<< + * self._checkStage("SCIPgetSolVal") + * var = expr + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_expr), __pyx_ptype_9pyscipopt_4scip_Variable); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":597 + * # fast track for Variable + * if isinstance(expr, Variable): + * self._checkStage("SCIPgetSolVal") # <<<<<<<<<<<<<< + * var = expr + * return SCIPgetSolVal(self.scip, self.sol, var.scip_var) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_checkStage); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_n_u_SCIPgetSolVal}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":598 + * if isinstance(expr, Variable): + * self._checkStage("SCIPgetSolVal") + * var = expr # <<<<<<<<<<<<<< + * return SCIPgetSolVal(self.scip, self.sol, var.scip_var) + * return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0) + */ + __pyx_t_2 = ((PyObject *)__pyx_v_expr); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":599 + * self._checkStage("SCIPgetSolVal") + * var = expr + * return SCIPgetSolVal(self.scip, self.sol, var.scip_var) # <<<<<<<<<<<<<< + * return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetSolVal(__pyx_cur_scope->__pyx_v_self->scip, __pyx_cur_scope->__pyx_v_self->sol, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":596 + * def __getitem__(self, Expr expr): + * # fast track for Variable + * if isinstance(expr, Variable): # <<<<<<<<<<<<<< + * self._checkStage("SCIPgetSolVal") + * var = expr + */ + } + + /* "src/pyscipopt/scip.pxi":600 + * var = expr + * return SCIPgetSolVal(self.scip, self.sol, var.scip_var) + * return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0) # <<<<<<<<<<<<<< + * + * def _evaluate(self, term): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_pf_9pyscipopt_4scip_8Solution_11__getitem___genexpr(((PyObject*)__pyx_cur_scope), __pyx_v_expr->terms); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_sum, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":594 + * return sol + * + * def __getitem__(self, Expr expr): # <<<<<<<<<<<<<< + * # fast track for Variable + * if isinstance(expr, Variable): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Solution.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XDECREF(__pyx_gb_9pyscipopt_4scip_8Solution_11__getitem___2generator4); + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":602 + * return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0) + * + * def _evaluate(self, term): # <<<<<<<<<<<<<< + * self._checkStage("SCIPgetSolVal") + * result = 1 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_5_evaluate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Solution_4_evaluate, "Solution._evaluate(self, term)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Solution_5_evaluate = {"_evaluate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Solution_5_evaluate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Solution_4_evaluate}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_5_evaluate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_term = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_evaluate (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_term,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_term)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 602, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_evaluate") < 0)) __PYX_ERR(0, 602, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_term = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_evaluate", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 602, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Solution._evaluate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_4_evaluate(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self), __pyx_v_term); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_4_evaluate(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, PyObject *__pyx_v_term) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_evaluate", 1); + + /* "src/pyscipopt/scip.pxi":603 + * + * def _evaluate(self, term): + * self._checkStage("SCIPgetSolVal") # <<<<<<<<<<<<<< + * result = 1 + * for var in term.vartuple: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_n_u_SCIPgetSolVal}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":604 + * def _evaluate(self, term): + * self._checkStage("SCIPgetSolVal") + * result = 1 # <<<<<<<<<<<<<< + * for var in term.vartuple: + * result *= SCIPgetSolVal(self.scip, self.sol, ( var).scip_var) + */ + __Pyx_INCREF(__pyx_int_1); + __pyx_v_result = __pyx_int_1; + + /* "src/pyscipopt/scip.pxi":605 + * self._checkStage("SCIPgetSolVal") + * result = 1 + * for var in term.vartuple: # <<<<<<<<<<<<<< + * result *= SCIPgetSolVal(self.scip, self.sol, ( var).scip_var) + * return result + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_term, __pyx_n_s_vartuple); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 605, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 605, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 605, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 605, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 605, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_6(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 605, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":606 + * result = 1 + * for var in term.vartuple: + * result *= SCIPgetSolVal(self.scip, self.sol, ( var).scip_var) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_1 = PyFloat_FromDouble(SCIPgetSolVal(__pyx_v_self->scip, __pyx_v_self->sol, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_var)->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":605 + * self._checkStage("SCIPgetSolVal") + * result = 1 + * for var in term.vartuple: # <<<<<<<<<<<<<< + * result *= SCIPgetSolVal(self.scip, self.sol, ( var).scip_var) + * return result + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":607 + * for var in term.vartuple: + * result *= SCIPgetSolVal(self.scip, self.sol, ( var).scip_var) + * return result # <<<<<<<<<<<<<< + * + * def __setitem__(self, Variable var, value): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":602 + * return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0) + * + * def _evaluate(self, term): # <<<<<<<<<<<<<< + * self._checkStage("SCIPgetSolVal") + * result = 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Solution._evaluate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":609 + * return result + * + * def __setitem__(self, Variable var, value): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetSolVal(self.scip, self.sol, var.scip_var, value)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Solution_7__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_var, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Solution_7__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_var, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 609, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_6__setitem__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self), ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_var), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Solution_6__setitem__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 1); + + /* "src/pyscipopt/scip.pxi":610 + * + * def __setitem__(self, Variable var, value): + * PY_SCIP_CALL(SCIPsetSolVal(self.scip, self.sol, var.scip_var, value)) # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 610, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetSolVal(__pyx_v_self->scip, __pyx_v_self->sol, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":609 + * return result + * + * def __setitem__(self, Variable var, value): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetSolVal(self.scip, self.sol, var.scip_var, value)) + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Solution.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":612 + * PY_SCIP_CALL(SCIPsetSolVal(self.scip, self.sol, var.scip_var, value)) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * cdef SCIP_VAR* scip_var + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_9__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_9__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_8__repr__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_8__repr__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self) { + SCIP_VAR *__pyx_v_scip_var; + PyObject *__pyx_v_vals = NULL; + int __pyx_v_i; + PyObject *__pyx_v_cname = NULL; + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/scip.pxi":615 + * cdef SCIP_VAR* scip_var + * + * vals = {} # <<<<<<<<<<<<<< + * self._checkStage("SCIPgetSolVal") + * for i in range(SCIPgetNOrigVars(self.scip)): + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_vals = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":616 + * + * vals = {} + * self._checkStage("SCIPgetSolVal") # <<<<<<<<<<<<<< + * for i in range(SCIPgetNOrigVars(self.scip)): + * scip_var = SCIPgetOrigVars(self.scip)[i] + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_n_u_SCIPgetSolVal}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":617 + * vals = {} + * self._checkStage("SCIPgetSolVal") + * for i in range(SCIPgetNOrigVars(self.scip)): # <<<<<<<<<<<<<< + * scip_var = SCIPgetOrigVars(self.scip)[i] + * + */ + __pyx_t_4 = SCIPgetNOrigVars(__pyx_v_self->scip); + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":618 + * self._checkStage("SCIPgetSolVal") + * for i in range(SCIPgetNOrigVars(self.scip)): + * scip_var = SCIPgetOrigVars(self.scip)[i] # <<<<<<<<<<<<<< + * + * # extract name + */ + __pyx_v_scip_var = (SCIPgetOrigVars(__pyx_v_self->scip)[__pyx_v_i]); + + /* "src/pyscipopt/scip.pxi":621 + * + * # extract name + * cname = bytes(SCIPvarGetName(scip_var)) # <<<<<<<<<<<<<< + * name = cname.decode('utf-8') + * + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPvarGetName(__pyx_v_scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_cname, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":622 + * # extract name + * cname = bytes(SCIPvarGetName(scip_var)) + * name = cname.decode('utf-8') # <<<<<<<<<<<<<< + * + * vals[name] = SCIPgetSolVal(self.scip, self.sol, scip_var) + */ + __pyx_t_2 = __Pyx_decode_bytes(__pyx_v_cname, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":624 + * name = cname.decode('utf-8') + * + * vals[name] = SCIPgetSolVal(self.scip, self.sol, scip_var) # <<<<<<<<<<<<<< + * return str(vals) + * + */ + __pyx_t_2 = PyFloat_FromDouble(SCIPgetSolVal(__pyx_v_self->scip, __pyx_v_self->sol, __pyx_v_scip_var)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely((PyDict_SetItem(__pyx_v_vals, __pyx_v_name, __pyx_t_2) < 0))) __PYX_ERR(0, 624, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + + /* "src/pyscipopt/scip.pxi":625 + * + * vals[name] = SCIPgetSolVal(self.scip, self.sol, scip_var) + * return str(vals) # <<<<<<<<<<<<<< + * + * def _checkStage(self, method): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_Str(__pyx_v_vals); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":612 + * PY_SCIP_CALL(SCIPsetSolVal(self.scip, self.sol, var.scip_var, value)) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * cdef SCIP_VAR* scip_var + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Solution.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_vals); + __Pyx_XDECREF(__pyx_v_cname); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":627 + * return str(vals) + * + * def _checkStage(self, method): # <<<<<<<<<<<<<< + * if method in ["SCIPgetSolVal", "getSolObjVal"]: + * if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_11_checkStage(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Solution_10_checkStage, "Solution._checkStage(self, method)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Solution_11_checkStage = {"_checkStage", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Solution_11_checkStage, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Solution_10_checkStage}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_11_checkStage(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_method = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_checkStage (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_method,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_method)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 627, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "_checkStage") < 0)) __PYX_ERR(0, 627, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_method = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_checkStage", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 627, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Solution._checkStage", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_10_checkStage(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self), __pyx_v_method); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_10_checkStage(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, PyObject *__pyx_v_method) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_UCS4 __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_checkStage", 1); + + /* "src/pyscipopt/scip.pxi":628 + * + * def _checkStage(self, method): + * if method in ["SCIPgetSolVal", "getSolObjVal"]: # <<<<<<<<<<<<<< + * if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING: + * raise Warning(f"{method} can only be called with a valid solution or in stage SOLVING (current stage: {SCIPgetStage(self.scip)})") + */ + __Pyx_INCREF(__pyx_v_method); + __pyx_t_1 = __pyx_v_method; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_SCIPgetSolVal, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 628, __pyx_L1_error) + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_getSolObjVal, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 628, __pyx_L1_error) + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + if (__pyx_t_3) { + + /* "src/pyscipopt/scip.pxi":629 + * def _checkStage(self, method): + * if method in ["SCIPgetSolVal", "getSolObjVal"]: + * if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning(f"{method} can only be called with a valid solution or in stage SOLVING (current stage: {SCIPgetStage(self.scip)})") + * + */ + __pyx_t_2 = (__pyx_v_self->sol == NULL); + if (__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_2 = (SCIPgetStage(__pyx_v_self->scip) != SCIP_STAGE_SOLVING); + __pyx_t_3 = __pyx_t_2; + __pyx_L7_bool_binop_done:; + if (unlikely(__pyx_t_3)) { + + /* "src/pyscipopt/scip.pxi":630 + * if method in ["SCIPgetSolVal", "getSolObjVal"]: + * if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING: + * raise Warning(f"{method} can only be called with a valid solution or in stage SOLVING (current stage: {SCIPgetStage(self.scip)})") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = 0; + __pyx_t_5 = 127; + __pyx_t_6 = __Pyx_PyObject_FormatSimple(__pyx_v_method, __pyx_empty_unicode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) > __pyx_t_5) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_6) : __pyx_t_5; + __pyx_t_4 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_kp_u_can_only_be_called_with_a_valid); + __pyx_t_4 += 78; + __Pyx_GIVEREF(__pyx_kp_u_can_only_be_called_with_a_valid); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_kp_u_can_only_be_called_with_a_valid); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_STAGE(SCIPgetStage(__pyx_v_self->scip)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_t_6, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_5) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_5; + __pyx_t_4 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_kp_u__6); + __pyx_t_4 += 1; + __Pyx_GIVEREF(__pyx_kp_u__6); + PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_kp_u__6); + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_1, 4, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 630, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":629 + * def _checkStage(self, method): + * if method in ["SCIPgetSolVal", "getSolObjVal"]: + * if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning(f"{method} can only be called with a valid solution or in stage SOLVING (current stage: {SCIPgetStage(self.scip)})") + * + */ + } + + /* "src/pyscipopt/scip.pxi":628 + * + * def _checkStage(self, method): + * if method in ["SCIPgetSolVal", "getSolObjVal"]: # <<<<<<<<<<<<<< + * if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING: + * raise Warning(f"{method} can only be called with a valid solution or in stage SOLVING (current stage: {SCIPgetStage(self.scip)})") + */ + } + + /* "src/pyscipopt/scip.pxi":627 + * return str(vals) + * + * def _checkStage(self, method): # <<<<<<<<<<<<<< + * if method in ["SCIPgetSolVal", "getSolObjVal"]: + * if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Solution._checkStage", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1904 + * cdef SCIP* scip + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * + * @staticmethod + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Solution_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Solution_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Solution_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Solution_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Solution_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Solution_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Solution_12__reduce_cython__, "Solution.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Solution_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Solution_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Solution_12__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_12__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_self_sol_cannot_be_con, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Solution.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Solution_14__setstate_cython__, "Solution.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Solution_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Solution_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Solution_14__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Solution_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Solution.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Solution_14__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Solution_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_self_sol_cannot_be_con, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Solution.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":637 + * + * @staticmethod + * cdef create(SCIP_BOUNDCHG* scip_boundchg): # <<<<<<<<<<<<<< + * if scip_boundchg == NULL: + * raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_11BoundChange_create(SCIP_BOUNDCHG *__pyx_v_scip_boundchg) { + struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_boundchg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":638 + * @staticmethod + * cdef create(SCIP_BOUNDCHG* scip_boundchg): + * if scip_boundchg == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL") + * boundchg = BoundChange() + */ + __pyx_t_1 = (__pyx_v_scip_boundchg == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":639 + * cdef create(SCIP_BOUNDCHG* scip_boundchg): + * if scip_boundchg == NULL: + * raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL") # <<<<<<<<<<<<<< + * boundchg = BoundChange() + * boundchg.scip_boundchg = scip_boundchg + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 639, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":638 + * @staticmethod + * cdef create(SCIP_BOUNDCHG* scip_boundchg): + * if scip_boundchg == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL") + * boundchg = BoundChange() + */ + } + + /* "src/pyscipopt/scip.pxi":640 + * if scip_boundchg == NULL: + * raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL") + * boundchg = BoundChange() # <<<<<<<<<<<<<< + * boundchg.scip_boundchg = scip_boundchg + * return boundchg + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_BoundChange)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 640, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_boundchg = ((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":641 + * raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL") + * boundchg = BoundChange() + * boundchg.scip_boundchg = scip_boundchg # <<<<<<<<<<<<<< + * return boundchg + * + */ + __pyx_v_boundchg->scip_boundchg = __pyx_v_scip_boundchg; + + /* "src/pyscipopt/scip.pxi":642 + * boundchg = BoundChange() + * boundchg.scip_boundchg = scip_boundchg + * return boundchg # <<<<<<<<<<<<<< + * + * def getNewBound(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_boundchg); + __pyx_r = ((PyObject *)__pyx_v_boundchg); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":637 + * + * @staticmethod + * cdef create(SCIP_BOUNDCHG* scip_boundchg): # <<<<<<<<<<<<<< + * if scip_boundchg == NULL: + * raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_boundchg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":644 + * return boundchg + * + * def getNewBound(self): # <<<<<<<<<<<<<< + * """Returns the new value of the bound in the bound change.""" + * return SCIPboundchgGetNewbound(self.scip_boundchg) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_1getNewBound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_11BoundChange_getNewBound, "BoundChange.getNewBound(self)\nReturns the new value of the bound in the bound change."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_11BoundChange_1getNewBound = {"getNewBound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_1getNewBound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_getNewBound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_1getNewBound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNewBound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNewBound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNewBound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_11BoundChange_getNewBound(((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_getNewBound(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNewBound", 1); + + /* "src/pyscipopt/scip.pxi":646 + * def getNewBound(self): + * """Returns the new value of the bound in the bound change.""" + * return SCIPboundchgGetNewbound(self.scip_boundchg) # <<<<<<<<<<<<<< + * + * def getVar(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPboundchgGetNewbound(__pyx_v_self->scip_boundchg)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 646, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":644 + * return boundchg + * + * def getNewBound(self): # <<<<<<<<<<<<<< + * """Returns the new value of the bound in the bound change.""" + * return SCIPboundchgGetNewbound(self.scip_boundchg) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.getNewBound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":648 + * return SCIPboundchgGetNewbound(self.scip_boundchg) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """Returns the variable of the bound change.""" + * return Variable.create(SCIPboundchgGetVar(self.scip_boundchg)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_3getVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_11BoundChange_2getVar, "BoundChange.getVar(self)\nReturns the variable of the bound change."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_11BoundChange_3getVar = {"getVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_3getVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_2getVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_3getVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getVar", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getVar", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_11BoundChange_2getVar(((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_2getVar(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVar", 1); + + /* "src/pyscipopt/scip.pxi":650 + * def getVar(self): + * """Returns the variable of the bound change.""" + * return Variable.create(SCIPboundchgGetVar(self.scip_boundchg)) # <<<<<<<<<<<<<< + * + * def getBoundchgtype(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create(SCIPboundchgGetVar(__pyx_v_self->scip_boundchg)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 650, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":648 + * return SCIPboundchgGetNewbound(self.scip_boundchg) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """Returns the variable of the bound change.""" + * return Variable.create(SCIPboundchgGetVar(self.scip_boundchg)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.getVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":652 + * return Variable.create(SCIPboundchgGetVar(self.scip_boundchg)) + * + * def getBoundchgtype(self): # <<<<<<<<<<<<<< + * """Returns the bound change type of the bound change.""" + * return SCIPboundchgGetBoundchgtype(self.scip_boundchg) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_5getBoundchgtype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_11BoundChange_4getBoundchgtype, "BoundChange.getBoundchgtype(self)\nReturns the bound change type of the bound change."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_11BoundChange_5getBoundchgtype = {"getBoundchgtype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_5getBoundchgtype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_4getBoundchgtype}; +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_5getBoundchgtype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBoundchgtype (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBoundchgtype", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBoundchgtype", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_11BoundChange_4getBoundchgtype(((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_4getBoundchgtype(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBoundchgtype", 1); + + /* "src/pyscipopt/scip.pxi":654 + * def getBoundchgtype(self): + * """Returns the bound change type of the bound change.""" + * return SCIPboundchgGetBoundchgtype(self.scip_boundchg) # <<<<<<<<<<<<<< + * + * def getBoundtype(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_BOUNDCHGTYPE(SCIPboundchgGetBoundchgtype(__pyx_v_self->scip_boundchg)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":652 + * return Variable.create(SCIPboundchgGetVar(self.scip_boundchg)) + * + * def getBoundchgtype(self): # <<<<<<<<<<<<<< + * """Returns the bound change type of the bound change.""" + * return SCIPboundchgGetBoundchgtype(self.scip_boundchg) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.getBoundchgtype", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":656 + * return SCIPboundchgGetBoundchgtype(self.scip_boundchg) + * + * def getBoundtype(self): # <<<<<<<<<<<<<< + * """Returns the bound type of the bound change.""" + * return SCIPboundchgGetBoundtype(self.scip_boundchg) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_7getBoundtype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_11BoundChange_6getBoundtype, "BoundChange.getBoundtype(self)\nReturns the bound type of the bound change."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_11BoundChange_7getBoundtype = {"getBoundtype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_7getBoundtype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_6getBoundtype}; +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_7getBoundtype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBoundtype (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBoundtype", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBoundtype", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_11BoundChange_6getBoundtype(((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_6getBoundtype(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBoundtype", 1); + + /* "src/pyscipopt/scip.pxi":658 + * def getBoundtype(self): + * """Returns the bound type of the bound change.""" + * return SCIPboundchgGetBoundtype(self.scip_boundchg) # <<<<<<<<<<<<<< + * + * def isRedundant(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_BOUNDTYPE(SCIPboundchgGetBoundtype(__pyx_v_self->scip_boundchg)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":656 + * return SCIPboundchgGetBoundchgtype(self.scip_boundchg) + * + * def getBoundtype(self): # <<<<<<<<<<<<<< + * """Returns the bound type of the bound change.""" + * return SCIPboundchgGetBoundtype(self.scip_boundchg) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.getBoundtype", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":660 + * return SCIPboundchgGetBoundtype(self.scip_boundchg) + * + * def isRedundant(self): # <<<<<<<<<<<<<< + * """Returns whether the bound change is redundant due to a more global bound that is at least as strong.""" + * return SCIPboundchgIsRedundant(self.scip_boundchg) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_9isRedundant(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_11BoundChange_8isRedundant, "BoundChange.isRedundant(self)\nReturns whether the bound change is redundant due to a more global bound that is at least as strong."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_11BoundChange_9isRedundant = {"isRedundant", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_9isRedundant, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_8isRedundant}; +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_9isRedundant(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isRedundant (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isRedundant", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isRedundant", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_11BoundChange_8isRedundant(((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_8isRedundant(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isRedundant", 1); + + /* "src/pyscipopt/scip.pxi":662 + * def isRedundant(self): + * """Returns whether the bound change is redundant due to a more global bound that is at least as strong.""" + * return SCIPboundchgIsRedundant(self.scip_boundchg) # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPboundchgIsRedundant(__pyx_v_self->scip_boundchg)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":660 + * return SCIPboundchgGetBoundtype(self.scip_boundchg) + * + * def isRedundant(self): # <<<<<<<<<<<<<< + * """Returns whether the bound change is redundant due to a more global bound that is at least as strong.""" + * return SCIPboundchgIsRedundant(self.scip_boundchg) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.isRedundant", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":664 + * return SCIPboundchgIsRedundant(self.scip_boundchg) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "{} {} {}".format(self.getVar(), + * _SCIP_BOUNDTYPE_TO_STRING[self.getBoundtype()], + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_11__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_11__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_11BoundChange_10__repr__(((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_10__repr__(struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/scip.pxi":665 + * + * def __repr__(self): + * return "{} {} {}".format(self.getVar(), # <<<<<<<<<<<<<< + * _SCIP_BOUNDTYPE_TO_STRING[self.getBoundtype()], + * self.getNewBound()) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__79, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getVar); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + + /* "src/pyscipopt/scip.pxi":666 + * def __repr__(self): + * return "{} {} {}".format(self.getVar(), + * _SCIP_BOUNDTYPE_TO_STRING[self.getBoundtype()], # <<<<<<<<<<<<<< + * self.getNewBound()) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_SCIP_BOUNDTYPE_TO_STRING); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getBoundtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":667 + * return "{} {} {}".format(self.getVar(), + * _SCIP_BOUNDTYPE_TO_STRING[self.getBoundtype()], + * self.getNewBound()) # <<<<<<<<<<<<<< + * + * cdef class DomainChanges: + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getNewBound); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_t_3, __pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 3+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":664 + * return SCIPboundchgIsRedundant(self.scip_boundchg) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "{} {} {}".format(self.getVar(), + * _SCIP_BOUNDTYPE_TO_STRING[self.getBoundtype()], + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_11BoundChange_12__reduce_cython__, "BoundChange.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_11BoundChange_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_12__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_11BoundChange_12__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_boundchg_cannot_be_con, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_11BoundChange_14__setstate_cython__, "BoundChange.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_11BoundChange_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_14__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_11BoundChange_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_11BoundChange_14__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_11BoundChange_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_BoundChange *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_boundchg_cannot_be_con, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.BoundChange.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":673 + * + * @staticmethod + * cdef create(SCIP_DOMCHG* scip_domchg): # <<<<<<<<<<<<<< + * if scip_domchg == NULL: + * raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_13DomainChanges_create(SCIP_DOMCHG *__pyx_v_scip_domchg) { + struct __pyx_obj_9pyscipopt_4scip_DomainChanges *__pyx_v_domchg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":674 + * @staticmethod + * cdef create(SCIP_DOMCHG* scip_domchg): + * if scip_domchg == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL") + * domchg = DomainChanges() + */ + __pyx_t_1 = (__pyx_v_scip_domchg == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":675 + * cdef create(SCIP_DOMCHG* scip_domchg): + * if scip_domchg == NULL: + * raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL") # <<<<<<<<<<<<<< + * domchg = DomainChanges() + * domchg.scip_domchg = scip_domchg + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 675, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":674 + * @staticmethod + * cdef create(SCIP_DOMCHG* scip_domchg): + * if scip_domchg == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL") + * domchg = DomainChanges() + */ + } + + /* "src/pyscipopt/scip.pxi":676 + * if scip_domchg == NULL: + * raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL") + * domchg = DomainChanges() # <<<<<<<<<<<<<< + * domchg.scip_domchg = scip_domchg + * return domchg + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_DomainChanges)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_domchg = ((struct __pyx_obj_9pyscipopt_4scip_DomainChanges *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":677 + * raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL") + * domchg = DomainChanges() + * domchg.scip_domchg = scip_domchg # <<<<<<<<<<<<<< + * return domchg + * + */ + __pyx_v_domchg->scip_domchg = __pyx_v_scip_domchg; + + /* "src/pyscipopt/scip.pxi":678 + * domchg = DomainChanges() + * domchg.scip_domchg = scip_domchg + * return domchg # <<<<<<<<<<<<<< + * + * def getBoundchgs(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_domchg); + __pyx_r = ((PyObject *)__pyx_v_domchg); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":673 + * + * @staticmethod + * cdef create(SCIP_DOMCHG* scip_domchg): # <<<<<<<<<<<<<< + * if scip_domchg == NULL: + * raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.DomainChanges.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_domchg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":680 + * return domchg + * + * def getBoundchgs(self): # <<<<<<<<<<<<<< + * """Returns the bound changes in the domain change.""" + * nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_13DomainChanges_1getBoundchgs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_13DomainChanges_getBoundchgs, "DomainChanges.getBoundchgs(self)\nReturns the bound changes in the domain change."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_13DomainChanges_1getBoundchgs = {"getBoundchgs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13DomainChanges_1getBoundchgs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13DomainChanges_getBoundchgs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_13DomainChanges_1getBoundchgs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBoundchgs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBoundchgs", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBoundchgs", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_13DomainChanges_getBoundchgs(((struct __pyx_obj_9pyscipopt_4scip_DomainChanges *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_13DomainChanges_getBoundchgs(struct __pyx_obj_9pyscipopt_4scip_DomainChanges *__pyx_v_self) { + int __pyx_v_nboundchgs; + int __pyx_9genexpr21__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBoundchgs", 1); + + /* "src/pyscipopt/scip.pxi":682 + * def getBoundchgs(self): + * """Returns the bound changes in the domain change.""" + * nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg) # <<<<<<<<<<<<<< + * return [BoundChange.create(SCIPdomchgGetBoundchg(self.scip_domchg, i)) + * for i in range(nboundchgs)] + */ + __pyx_v_nboundchgs = SCIPdomchgGetNBoundchgs(__pyx_v_self->scip_domchg); + + /* "src/pyscipopt/scip.pxi":683 + * """Returns the bound changes in the domain change.""" + * nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg) + * return [BoundChange.create(SCIPdomchgGetBoundchg(self.scip_domchg, i)) # <<<<<<<<<<<<<< + * for i in range(nboundchgs)] + * + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "src/pyscipopt/scip.pxi":684 + * nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg) + * return [BoundChange.create(SCIPdomchgGetBoundchg(self.scip_domchg, i)) + * for i in range(nboundchgs)] # <<<<<<<<<<<<<< + * + * cdef class Node: + */ + __pyx_t_2 = __pyx_v_nboundchgs; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_9genexpr21__pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/scip.pxi":683 + * """Returns the bound changes in the domain change.""" + * nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg) + * return [BoundChange.create(SCIPdomchgGetBoundchg(self.scip_domchg, i)) # <<<<<<<<<<<<<< + * for i in range(nboundchgs)] + * + */ + __pyx_t_5 = __pyx_f_9pyscipopt_4scip_11BoundChange_create(SCIPdomchgGetBoundchg(__pyx_v_self->scip_domchg, __pyx_9genexpr21__pyx_v_i)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 683, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":680 + * return domchg + * + * def getBoundchgs(self): # <<<<<<<<<<<<<< + * """Returns the bound changes in the domain change.""" + * nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.DomainChanges.getBoundchgs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_13DomainChanges_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_13DomainChanges_2__reduce_cython__, "DomainChanges.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_13DomainChanges_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13DomainChanges_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13DomainChanges_2__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_13DomainChanges_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_13DomainChanges_2__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_DomainChanges *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_13DomainChanges_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_DomainChanges *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_domchg_cannot_be_conve, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.DomainChanges.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_13DomainChanges_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_13DomainChanges_4__setstate_cython__, "DomainChanges.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_13DomainChanges_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13DomainChanges_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13DomainChanges_4__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_13DomainChanges_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.DomainChanges.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_13DomainChanges_4__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_DomainChanges *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_13DomainChanges_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_DomainChanges *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_domchg_cannot_be_conve, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.DomainChanges.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":690 + * + * @staticmethod + * cdef create(SCIP_NODE* scipnode): # <<<<<<<<<<<<<< + * if scipnode == NULL: + * return None + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_4Node_create(SCIP_NODE *__pyx_v_scipnode) { + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":691 + * @staticmethod + * cdef create(SCIP_NODE* scipnode): + * if scipnode == NULL: # <<<<<<<<<<<<<< + * return None + * node = Node() + */ + __pyx_t_1 = (__pyx_v_scipnode == NULL); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":692 + * cdef create(SCIP_NODE* scipnode): + * if scipnode == NULL: + * return None # <<<<<<<<<<<<<< + * node = Node() + * node.scip_node = scipnode + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":691 + * @staticmethod + * cdef create(SCIP_NODE* scipnode): + * if scipnode == NULL: # <<<<<<<<<<<<<< + * return None + * node = Node() + */ + } + + /* "src/pyscipopt/scip.pxi":693 + * if scipnode == NULL: + * return None + * node = Node() # <<<<<<<<<<<<<< + * node.scip_node = scipnode + * return node + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_node = ((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":694 + * return None + * node = Node() + * node.scip_node = scipnode # <<<<<<<<<<<<<< + * return node + * + */ + __pyx_v_node->scip_node = __pyx_v_scipnode; + + /* "src/pyscipopt/scip.pxi":695 + * node = Node() + * node.scip_node = scipnode + * return node # <<<<<<<<<<<<<< + * + * def getParent(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_node); + __pyx_r = ((PyObject *)__pyx_v_node); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":690 + * + * @staticmethod + * cdef create(SCIP_NODE* scipnode): # <<<<<<<<<<<<<< + * if scipnode == NULL: + * return None + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Node.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_node); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":697 + * return node + * + * def getParent(self): # <<<<<<<<<<<<<< + * """Retrieve parent node (or None if the node has no parent node).""" + * return Node.create(SCIPnodeGetParent(self.scip_node)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_1getParent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_getParent, "Node.getParent(self)\nRetrieve parent node (or None if the node has no parent node)."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_1getParent = {"getParent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_1getParent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_getParent}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_1getParent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getParent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getParent", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getParent", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_getParent(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_getParent(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getParent", 1); + + /* "src/pyscipopt/scip.pxi":699 + * def getParent(self): + * """Retrieve parent node (or None if the node has no parent node).""" + * return Node.create(SCIPnodeGetParent(self.scip_node)) # <<<<<<<<<<<<<< + * + * def getNumber(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(SCIPnodeGetParent(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":697 + * return node + * + * def getParent(self): # <<<<<<<<<<<<<< + * """Retrieve parent node (or None if the node has no parent node).""" + * return Node.create(SCIPnodeGetParent(self.scip_node)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.getParent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":701 + * return Node.create(SCIPnodeGetParent(self.scip_node)) + * + * def getNumber(self): # <<<<<<<<<<<<<< + * """Retrieve number of node.""" + * return SCIPnodeGetNumber(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_3getNumber(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_2getNumber, "Node.getNumber(self)\nRetrieve number of node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_3getNumber = {"getNumber", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_3getNumber, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_2getNumber}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_3getNumber(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNumber (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNumber", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNumber", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_2getNumber(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_2getNumber(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNumber", 1); + + /* "src/pyscipopt/scip.pxi":703 + * def getNumber(self): + * """Retrieve number of node.""" + * return SCIPnodeGetNumber(self.scip_node) # <<<<<<<<<<<<<< + * + * def getDepth(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPnodeGetNumber(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 703, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":701 + * return Node.create(SCIPnodeGetParent(self.scip_node)) + * + * def getNumber(self): # <<<<<<<<<<<<<< + * """Retrieve number of node.""" + * return SCIPnodeGetNumber(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.getNumber", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":705 + * return SCIPnodeGetNumber(self.scip_node) + * + * def getDepth(self): # <<<<<<<<<<<<<< + * """Retrieve depth of node.""" + * return SCIPnodeGetDepth(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_5getDepth(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_4getDepth, "Node.getDepth(self)\nRetrieve depth of node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_5getDepth = {"getDepth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_5getDepth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_4getDepth}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_5getDepth(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDepth (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getDepth", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDepth", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_4getDepth(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_4getDepth(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDepth", 1); + + /* "src/pyscipopt/scip.pxi":707 + * def getDepth(self): + * """Retrieve depth of node.""" + * return SCIPnodeGetDepth(self.scip_node) # <<<<<<<<<<<<<< + * + * def getType(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPnodeGetDepth(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":705 + * return SCIPnodeGetNumber(self.scip_node) + * + * def getDepth(self): # <<<<<<<<<<<<<< + * """Retrieve depth of node.""" + * return SCIPnodeGetDepth(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.getDepth", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":709 + * return SCIPnodeGetDepth(self.scip_node) + * + * def getType(self): # <<<<<<<<<<<<<< + * """Retrieve type of node.""" + * return SCIPnodeGetType(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_7getType(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_6getType, "Node.getType(self)\nRetrieve type of node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_7getType = {"getType", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_7getType, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_6getType}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_7getType(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getType (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getType", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getType", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_6getType(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_6getType(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getType", 1); + + /* "src/pyscipopt/scip.pxi":711 + * def getType(self): + * """Retrieve type of node.""" + * return SCIPnodeGetType(self.scip_node) # <<<<<<<<<<<<<< + * + * def getLowerbound(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIPnodeGetType(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":709 + * return SCIPnodeGetDepth(self.scip_node) + * + * def getType(self): # <<<<<<<<<<<<<< + * """Retrieve type of node.""" + * return SCIPnodeGetType(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.getType", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":713 + * return SCIPnodeGetType(self.scip_node) + * + * def getLowerbound(self): # <<<<<<<<<<<<<< + * """Retrieve lower bound of node.""" + * return SCIPnodeGetLowerbound(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_9getLowerbound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_8getLowerbound, "Node.getLowerbound(self)\nRetrieve lower bound of node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_9getLowerbound = {"getLowerbound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_9getLowerbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_8getLowerbound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_9getLowerbound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLowerbound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLowerbound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLowerbound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_8getLowerbound(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_8getLowerbound(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLowerbound", 1); + + /* "src/pyscipopt/scip.pxi":715 + * def getLowerbound(self): + * """Retrieve lower bound of node.""" + * return SCIPnodeGetLowerbound(self.scip_node) # <<<<<<<<<<<<<< + * + * def getEstimate(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPnodeGetLowerbound(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":713 + * return SCIPnodeGetType(self.scip_node) + * + * def getLowerbound(self): # <<<<<<<<<<<<<< + * """Retrieve lower bound of node.""" + * return SCIPnodeGetLowerbound(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.getLowerbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":717 + * return SCIPnodeGetLowerbound(self.scip_node) + * + * def getEstimate(self): # <<<<<<<<<<<<<< + * """Retrieve the estimated value of the best feasible solution in subtree of the node""" + * return SCIPnodeGetEstimate(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_11getEstimate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_10getEstimate, "Node.getEstimate(self)\nRetrieve the estimated value of the best feasible solution in subtree of the node"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_11getEstimate = {"getEstimate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_11getEstimate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_10getEstimate}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_11getEstimate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getEstimate (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getEstimate", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getEstimate", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_10getEstimate(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_10getEstimate(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getEstimate", 1); + + /* "src/pyscipopt/scip.pxi":719 + * def getEstimate(self): + * """Retrieve the estimated value of the best feasible solution in subtree of the node""" + * return SCIPnodeGetEstimate(self.scip_node) # <<<<<<<<<<<<<< + * + * def getAddedConss(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPnodeGetEstimate(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 719, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":717 + * return SCIPnodeGetLowerbound(self.scip_node) + * + * def getEstimate(self): # <<<<<<<<<<<<<< + * """Retrieve the estimated value of the best feasible solution in subtree of the node""" + * return SCIPnodeGetEstimate(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.getEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":721 + * return SCIPnodeGetEstimate(self.scip_node) + * + * def getAddedConss(self): # <<<<<<<<<<<<<< + * """Retrieve all constraints added at this node.""" + * cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_13getAddedConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_12getAddedConss, "Node.getAddedConss(self)\nRetrieve all constraints added at this node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_13getAddedConss = {"getAddedConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_13getAddedConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_12getAddedConss}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_13getAddedConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getAddedConss (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getAddedConss", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getAddedConss", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_12getAddedConss(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_12getAddedConss(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + int __pyx_v_addedconsssize; + SCIP_CONS **__pyx_v_addedconss; + int __pyx_v_nconss; + PyObject *__pyx_v_constraints = NULL; + int __pyx_9genexpr22__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getAddedConss", 1); + + /* "src/pyscipopt/scip.pxi":723 + * def getAddedConss(self): + * """Retrieve all constraints added at this node.""" + * cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node) # <<<<<<<<<<<<<< + * if addedconsssize == 0: + * return [] + */ + __pyx_v_addedconsssize = SCIPnodeGetNAddedConss(__pyx_v_self->scip_node); + + /* "src/pyscipopt/scip.pxi":724 + * """Retrieve all constraints added at this node.""" + * cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node) + * if addedconsssize == 0: # <<<<<<<<<<<<<< + * return [] + * cdef SCIP_CONS** addedconss = malloc(addedconsssize * sizeof(SCIP_CONS*)) + */ + __pyx_t_1 = (__pyx_v_addedconsssize == 0); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":725 + * cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node) + * if addedconsssize == 0: + * return [] # <<<<<<<<<<<<<< + * cdef SCIP_CONS** addedconss = malloc(addedconsssize * sizeof(SCIP_CONS*)) + * cdef int nconss + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 725, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":724 + * """Retrieve all constraints added at this node.""" + * cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node) + * if addedconsssize == 0: # <<<<<<<<<<<<<< + * return [] + * cdef SCIP_CONS** addedconss = malloc(addedconsssize * sizeof(SCIP_CONS*)) + */ + } + + /* "src/pyscipopt/scip.pxi":726 + * if addedconsssize == 0: + * return [] + * cdef SCIP_CONS** addedconss = malloc(addedconsssize * sizeof(SCIP_CONS*)) # <<<<<<<<<<<<<< + * cdef int nconss + * SCIPnodeGetAddedConss(self.scip_node, addedconss, &nconss, addedconsssize) + */ + __pyx_v_addedconss = ((SCIP_CONS **)malloc((__pyx_v_addedconsssize * (sizeof(SCIP_CONS *))))); + + /* "src/pyscipopt/scip.pxi":728 + * cdef SCIP_CONS** addedconss = malloc(addedconsssize * sizeof(SCIP_CONS*)) + * cdef int nconss + * SCIPnodeGetAddedConss(self.scip_node, addedconss, &nconss, addedconsssize) # <<<<<<<<<<<<<< + * assert nconss == addedconsssize + * constraints = [Constraint.create(addedconss[i]) for i in range(nconss)] + */ + SCIPnodeGetAddedConss(__pyx_v_self->scip_node, __pyx_v_addedconss, (&__pyx_v_nconss), __pyx_v_addedconsssize); + + /* "src/pyscipopt/scip.pxi":729 + * cdef int nconss + * SCIPnodeGetAddedConss(self.scip_node, addedconss, &nconss, addedconsssize) + * assert nconss == addedconsssize # <<<<<<<<<<<<<< + * constraints = [Constraint.create(addedconss[i]) for i in range(nconss)] + * free(addedconss) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (__pyx_v_nconss == __pyx_v_addedconsssize); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 729, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 729, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":730 + * SCIPnodeGetAddedConss(self.scip_node, addedconss, &nconss, addedconsssize) + * assert nconss == addedconsssize + * constraints = [Constraint.create(addedconss[i]) for i in range(nconss)] # <<<<<<<<<<<<<< + * free(addedconss) + * return constraints + */ + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 730, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_v_nconss; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_9genexpr22__pyx_v_i = __pyx_t_5; + __pyx_t_6 = __pyx_f_9pyscipopt_4scip_10Constraint_create((__pyx_v_addedconss[__pyx_9genexpr22__pyx_v_i])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 730, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 730, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __pyx_v_constraints = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":731 + * assert nconss == addedconsssize + * constraints = [Constraint.create(addedconss[i]) for i in range(nconss)] + * free(addedconss) # <<<<<<<<<<<<<< + * return constraints + * + */ + free(__pyx_v_addedconss); + + /* "src/pyscipopt/scip.pxi":732 + * constraints = [Constraint.create(addedconss[i]) for i in range(nconss)] + * free(addedconss) + * return constraints # <<<<<<<<<<<<<< + * + * def getNAddedConss(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_constraints); + __pyx_r = __pyx_v_constraints; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":721 + * return SCIPnodeGetEstimate(self.scip_node) + * + * def getAddedConss(self): # <<<<<<<<<<<<<< + * """Retrieve all constraints added at this node.""" + * cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Node.getAddedConss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":734 + * return constraints + * + * def getNAddedConss(self): # <<<<<<<<<<<<<< + * """Retrieve number of added constraints at this node""" + * return SCIPnodeGetNAddedConss(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_15getNAddedConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_14getNAddedConss, "Node.getNAddedConss(self)\nRetrieve number of added constraints at this node"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_15getNAddedConss = {"getNAddedConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_15getNAddedConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_14getNAddedConss}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_15getNAddedConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNAddedConss (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNAddedConss", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNAddedConss", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_14getNAddedConss(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_14getNAddedConss(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNAddedConss", 1); + + /* "src/pyscipopt/scip.pxi":736 + * def getNAddedConss(self): + * """Retrieve number of added constraints at this node""" + * return SCIPnodeGetNAddedConss(self.scip_node) # <<<<<<<<<<<<<< + * + * def isActive(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPnodeGetNAddedConss(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":734 + * return constraints + * + * def getNAddedConss(self): # <<<<<<<<<<<<<< + * """Retrieve number of added constraints at this node""" + * return SCIPnodeGetNAddedConss(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.getNAddedConss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":738 + * return SCIPnodeGetNAddedConss(self.scip_node) + * + * def isActive(self): # <<<<<<<<<<<<<< + * """Is the node in the path to the current node?""" + * return SCIPnodeIsActive(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_17isActive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_16isActive, "Node.isActive(self)\nIs the node in the path to the current node?"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_17isActive = {"isActive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_17isActive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_16isActive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_17isActive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isActive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isActive", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isActive", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_16isActive(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_16isActive(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isActive", 1); + + /* "src/pyscipopt/scip.pxi":740 + * def isActive(self): + * """Is the node in the path to the current node?""" + * return SCIPnodeIsActive(self.scip_node) # <<<<<<<<<<<<<< + * + * def isPropagatedAgain(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPnodeIsActive(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":738 + * return SCIPnodeGetNAddedConss(self.scip_node) + * + * def isActive(self): # <<<<<<<<<<<<<< + * """Is the node in the path to the current node?""" + * return SCIPnodeIsActive(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.isActive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":742 + * return SCIPnodeIsActive(self.scip_node) + * + * def isPropagatedAgain(self): # <<<<<<<<<<<<<< + * """Is the node marked to be propagated again?""" + * return SCIPnodeIsPropagatedAgain(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_19isPropagatedAgain(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_18isPropagatedAgain, "Node.isPropagatedAgain(self)\nIs the node marked to be propagated again?"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_19isPropagatedAgain = {"isPropagatedAgain", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_19isPropagatedAgain, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_18isPropagatedAgain}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_19isPropagatedAgain(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isPropagatedAgain (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isPropagatedAgain", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isPropagatedAgain", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_18isPropagatedAgain(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_18isPropagatedAgain(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isPropagatedAgain", 1); + + /* "src/pyscipopt/scip.pxi":744 + * def isPropagatedAgain(self): + * """Is the node marked to be propagated again?""" + * return SCIPnodeIsPropagatedAgain(self.scip_node) # <<<<<<<<<<<<<< + * + * def getNParentBranchings(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPnodeIsPropagatedAgain(__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":742 + * return SCIPnodeIsActive(self.scip_node) + * + * def isPropagatedAgain(self): # <<<<<<<<<<<<<< + * """Is the node marked to be propagated again?""" + * return SCIPnodeIsPropagatedAgain(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.isPropagatedAgain", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":746 + * return SCIPnodeIsPropagatedAgain(self.scip_node) + * + * def getNParentBranchings(self): # <<<<<<<<<<<<<< + * """Retrieve the number of variable branchings that were performed in the parent node to create this node.""" + * cdef SCIP_VAR* dummy_branchvars + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_21getNParentBranchings(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_20getNParentBranchings, "Node.getNParentBranchings(self)\nRetrieve the number of variable branchings that were performed in the parent node to create this node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_21getNParentBranchings = {"getNParentBranchings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_21getNParentBranchings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_20getNParentBranchings}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_21getNParentBranchings(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNParentBranchings (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNParentBranchings", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNParentBranchings", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_20getNParentBranchings(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_20getNParentBranchings(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + SCIP_VAR *__pyx_v_dummy_branchvars; + SCIP_Real __pyx_v_dummy_branchbounds; + SCIP_BOUNDTYPE __pyx_v_dummy_boundtypes; + int __pyx_v_nbranchvars; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNParentBranchings", 1); + + /* "src/pyscipopt/scip.pxi":755 + * # number of parent branchings, i.e., SCIPnodeGetNParentBranchings() does + * # not exist. + * SCIPnodeGetParentBranchings(self.scip_node, &dummy_branchvars, # <<<<<<<<<<<<<< + * &dummy_branchbounds, &dummy_boundtypes, + * &nbranchvars, 0) + */ + SCIPnodeGetParentBranchings(__pyx_v_self->scip_node, (&__pyx_v_dummy_branchvars), (&__pyx_v_dummy_branchbounds), (&__pyx_v_dummy_boundtypes), (&__pyx_v_nbranchvars), 0); + + /* "src/pyscipopt/scip.pxi":758 + * &dummy_branchbounds, &dummy_boundtypes, + * &nbranchvars, 0) + * return nbranchvars # <<<<<<<<<<<<<< + * + * def getParentBranchings(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_nbranchvars); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":746 + * return SCIPnodeIsPropagatedAgain(self.scip_node) + * + * def getNParentBranchings(self): # <<<<<<<<<<<<<< + * """Retrieve the number of variable branchings that were performed in the parent node to create this node.""" + * cdef SCIP_VAR* dummy_branchvars + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.getNParentBranchings", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":760 + * return nbranchvars + * + * def getParentBranchings(self): # <<<<<<<<<<<<<< + * """Retrieve the set of variable branchings that were performed in the parent node to create this node.""" + * cdef int nbranchvars = self.getNParentBranchings() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_23getParentBranchings(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_22getParentBranchings, "Node.getParentBranchings(self)\nRetrieve the set of variable branchings that were performed in the parent node to create this node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_23getParentBranchings = {"getParentBranchings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_23getParentBranchings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_22getParentBranchings}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_23getParentBranchings(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getParentBranchings (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getParentBranchings", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getParentBranchings", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_22getParentBranchings(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_22getParentBranchings(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + int __pyx_v_nbranchvars; + SCIP_VAR **__pyx_v_branchvars; + SCIP_Real *__pyx_v_branchbounds; + SCIP_BOUNDTYPE *__pyx_v_boundtypes; + PyObject *__pyx_v_py_variables = NULL; + PyObject *__pyx_v_py_branchbounds = NULL; + PyObject *__pyx_v_py_boundtypes = NULL; + int __pyx_9genexpr23__pyx_v_i; + int __pyx_9genexpr24__pyx_v_i; + int __pyx_9genexpr25__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getParentBranchings", 1); + + /* "src/pyscipopt/scip.pxi":762 + * def getParentBranchings(self): + * """Retrieve the set of variable branchings that were performed in the parent node to create this node.""" + * cdef int nbranchvars = self.getNParentBranchings() # <<<<<<<<<<<<<< + * if nbranchvars == 0: + * return None + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getNParentBranchings); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 762, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_nbranchvars = __pyx_t_4; + + /* "src/pyscipopt/scip.pxi":763 + * """Retrieve the set of variable branchings that were performed in the parent node to create this node.""" + * cdef int nbranchvars = self.getNParentBranchings() + * if nbranchvars == 0: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_5 = (__pyx_v_nbranchvars == 0); + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":764 + * cdef int nbranchvars = self.getNParentBranchings() + * if nbranchvars == 0: + * return None # <<<<<<<<<<<<<< + * + * cdef SCIP_VAR** branchvars = malloc(nbranchvars * sizeof(SCIP_VAR*)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":763 + * """Retrieve the set of variable branchings that were performed in the parent node to create this node.""" + * cdef int nbranchvars = self.getNParentBranchings() + * if nbranchvars == 0: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "src/pyscipopt/scip.pxi":766 + * return None + * + * cdef SCIP_VAR** branchvars = malloc(nbranchvars * sizeof(SCIP_VAR*)) # <<<<<<<<<<<<<< + * cdef SCIP_Real* branchbounds = malloc(nbranchvars * sizeof(SCIP_Real)) + * cdef SCIP_BOUNDTYPE* boundtypes = malloc(nbranchvars * sizeof(SCIP_BOUNDTYPE)) + */ + __pyx_v_branchvars = ((SCIP_VAR **)malloc((__pyx_v_nbranchvars * (sizeof(SCIP_VAR *))))); + + /* "src/pyscipopt/scip.pxi":767 + * + * cdef SCIP_VAR** branchvars = malloc(nbranchvars * sizeof(SCIP_VAR*)) + * cdef SCIP_Real* branchbounds = malloc(nbranchvars * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * cdef SCIP_BOUNDTYPE* boundtypes = malloc(nbranchvars * sizeof(SCIP_BOUNDTYPE)) + * + */ + __pyx_v_branchbounds = ((SCIP_Real *)malloc((__pyx_v_nbranchvars * (sizeof(SCIP_Real))))); + + /* "src/pyscipopt/scip.pxi":768 + * cdef SCIP_VAR** branchvars = malloc(nbranchvars * sizeof(SCIP_VAR*)) + * cdef SCIP_Real* branchbounds = malloc(nbranchvars * sizeof(SCIP_Real)) + * cdef SCIP_BOUNDTYPE* boundtypes = malloc(nbranchvars * sizeof(SCIP_BOUNDTYPE)) # <<<<<<<<<<<<<< + * + * SCIPnodeGetParentBranchings(self.scip_node, branchvars, branchbounds, + */ + __pyx_v_boundtypes = ((SCIP_BOUNDTYPE *)malloc((__pyx_v_nbranchvars * (sizeof(SCIP_BOUNDTYPE))))); + + /* "src/pyscipopt/scip.pxi":770 + * cdef SCIP_BOUNDTYPE* boundtypes = malloc(nbranchvars * sizeof(SCIP_BOUNDTYPE)) + * + * SCIPnodeGetParentBranchings(self.scip_node, branchvars, branchbounds, # <<<<<<<<<<<<<< + * boundtypes, &nbranchvars, nbranchvars) + * + */ + SCIPnodeGetParentBranchings(__pyx_v_self->scip_node, __pyx_v_branchvars, __pyx_v_branchbounds, __pyx_v_boundtypes, (&__pyx_v_nbranchvars), __pyx_v_nbranchvars); + + /* "src/pyscipopt/scip.pxi":773 + * boundtypes, &nbranchvars, nbranchvars) + * + * py_variables = [Variable.create(branchvars[i]) for i in range(nbranchvars)] # <<<<<<<<<<<<<< + * py_branchbounds = [branchbounds[i] for i in range(nbranchvars)] + * py_boundtypes = [boundtypes[i] for i in range(nbranchvars)] + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __pyx_v_nbranchvars; + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr23__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_branchvars[__pyx_9genexpr23__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 773, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_py_variables = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":774 + * + * py_variables = [Variable.create(branchvars[i]) for i in range(nbranchvars)] + * py_branchbounds = [branchbounds[i] for i in range(nbranchvars)] # <<<<<<<<<<<<<< + * py_boundtypes = [boundtypes[i] for i in range(nbranchvars)] + * + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __pyx_v_nbranchvars; + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr24__pyx_v_i = __pyx_t_7; + __pyx_t_2 = PyFloat_FromDouble((__pyx_v_branchbounds[__pyx_9genexpr24__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 774, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_py_branchbounds = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":775 + * py_variables = [Variable.create(branchvars[i]) for i in range(nbranchvars)] + * py_branchbounds = [branchbounds[i] for i in range(nbranchvars)] + * py_boundtypes = [boundtypes[i] for i in range(nbranchvars)] # <<<<<<<<<<<<<< + * + * free(boundtypes) + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __pyx_v_nbranchvars; + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr25__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __Pyx_PyInt_From_SCIP_BOUNDTYPE((__pyx_v_boundtypes[__pyx_9genexpr25__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_py_boundtypes = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":777 + * py_boundtypes = [boundtypes[i] for i in range(nbranchvars)] + * + * free(boundtypes) # <<<<<<<<<<<<<< + * free(branchbounds) + * free(branchvars) + */ + free(__pyx_v_boundtypes); + + /* "src/pyscipopt/scip.pxi":778 + * + * free(boundtypes) + * free(branchbounds) # <<<<<<<<<<<<<< + * free(branchvars) + * return py_variables, py_branchbounds, py_boundtypes + */ + free(__pyx_v_branchbounds); + + /* "src/pyscipopt/scip.pxi":779 + * free(boundtypes) + * free(branchbounds) + * free(branchvars) # <<<<<<<<<<<<<< + * return py_variables, py_branchbounds, py_boundtypes + * + */ + free(__pyx_v_branchvars); + + /* "src/pyscipopt/scip.pxi":780 + * free(branchbounds) + * free(branchvars) + * return py_variables, py_branchbounds, py_boundtypes # <<<<<<<<<<<<<< + * + * def getNDomchg(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_py_variables); + __Pyx_GIVEREF(__pyx_v_py_variables); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_py_variables)) __PYX_ERR(0, 780, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_py_branchbounds); + __Pyx_GIVEREF(__pyx_v_py_branchbounds); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_py_branchbounds)) __PYX_ERR(0, 780, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_py_boundtypes); + __Pyx_GIVEREF(__pyx_v_py_boundtypes); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_py_boundtypes)) __PYX_ERR(0, 780, __pyx_L1_error); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":760 + * return nbranchvars + * + * def getParentBranchings(self): # <<<<<<<<<<<<<< + * """Retrieve the set of variable branchings that were performed in the parent node to create this node.""" + * cdef int nbranchvars = self.getNParentBranchings() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Node.getParentBranchings", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_py_variables); + __Pyx_XDECREF(__pyx_v_py_branchbounds); + __Pyx_XDECREF(__pyx_v_py_boundtypes); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":782 + * return py_variables, py_branchbounds, py_boundtypes + * + * def getNDomchg(self): # <<<<<<<<<<<<<< + * """Retrieve the number of bound changes due to branching, constraint propagation, and propagation.""" + * cdef int nbranchings + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_25getNDomchg(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_24getNDomchg, "Node.getNDomchg(self)\nRetrieve the number of bound changes due to branching, constraint propagation, and propagation."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_25getNDomchg = {"getNDomchg", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_25getNDomchg, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_24getNDomchg}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_25getNDomchg(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNDomchg (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNDomchg", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNDomchg", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_24getNDomchg(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_24getNDomchg(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + int __pyx_v_nbranchings; + int __pyx_v_nconsprop; + int __pyx_v_nprop; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNDomchg", 1); + + /* "src/pyscipopt/scip.pxi":787 + * cdef int nconsprop + * cdef int nprop + * SCIPnodeGetNDomchg(self.scip_node, &nbranchings, &nconsprop, &nprop) # <<<<<<<<<<<<<< + * return nbranchings, nconsprop, nprop + * + */ + SCIPnodeGetNDomchg(__pyx_v_self->scip_node, (&__pyx_v_nbranchings), (&__pyx_v_nconsprop), (&__pyx_v_nprop)); + + /* "src/pyscipopt/scip.pxi":788 + * cdef int nprop + * SCIPnodeGetNDomchg(self.scip_node, &nbranchings, &nconsprop, &nprop) + * return nbranchings, nconsprop, nprop # <<<<<<<<<<<<<< + * + * def getDomchg(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_nbranchings); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_nconsprop); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nprop); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 788, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 788, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(0, 788, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3)) __PYX_ERR(0, 788, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":782 + * return py_variables, py_branchbounds, py_boundtypes + * + * def getNDomchg(self): # <<<<<<<<<<<<<< + * """Retrieve the number of bound changes due to branching, constraint propagation, and propagation.""" + * cdef int nbranchings + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Node.getNDomchg", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":790 + * return nbranchings, nconsprop, nprop + * + * def getDomchg(self): # <<<<<<<<<<<<<< + * """Retrieve domain changes for this node.""" + * cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_27getDomchg(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_26getDomchg, "Node.getDomchg(self)\nRetrieve domain changes for this node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_27getDomchg = {"getDomchg", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_27getDomchg, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_26getDomchg}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_27getDomchg(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDomchg (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getDomchg", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDomchg", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_26getDomchg(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_26getDomchg(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + SCIP_DOMCHG *__pyx_v_domchg; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDomchg", 1); + + /* "src/pyscipopt/scip.pxi":792 + * def getDomchg(self): + * """Retrieve domain changes for this node.""" + * cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node) # <<<<<<<<<<<<<< + * if domchg == NULL: + * return None + */ + __pyx_v_domchg = SCIPnodeGetDomchg(__pyx_v_self->scip_node); + + /* "src/pyscipopt/scip.pxi":793 + * """Retrieve domain changes for this node.""" + * cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node) + * if domchg == NULL: # <<<<<<<<<<<<<< + * return None + * return DomainChanges.create(domchg) + */ + __pyx_t_1 = (__pyx_v_domchg == NULL); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":794 + * cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node) + * if domchg == NULL: + * return None # <<<<<<<<<<<<<< + * return DomainChanges.create(domchg) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":793 + * """Retrieve domain changes for this node.""" + * cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node) + * if domchg == NULL: # <<<<<<<<<<<<<< + * return None + * return DomainChanges.create(domchg) + */ + } + + /* "src/pyscipopt/scip.pxi":795 + * if domchg == NULL: + * return None + * return DomainChanges.create(domchg) # <<<<<<<<<<<<<< + * + * def __hash__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_13DomainChanges_create(__pyx_v_domchg); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 795, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":790 + * return nbranchings, nconsprop, nprop + * + * def getDomchg(self): # <<<<<<<<<<<<<< + * """Retrieve domain changes for this node.""" + * cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Node.getDomchg", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":797 + * return DomainChanges.create(domchg) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_node) + * + */ + +/* Python wrapper */ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_4Node_29__hash__(PyObject *__pyx_v_self); /*proto*/ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_4Node_29__hash__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_28__hash__(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_hash_t __pyx_pf_9pyscipopt_4scip_4Node_28__hash__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_hash_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__hash__", 1); + + /* "src/pyscipopt/scip.pxi":798 + * + * def __hash__(self): + * return hash(self.scip_node) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->scip_node)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 798, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 798, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":797 + * return DomainChanges.create(domchg) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_node) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Node.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":800 + * return hash(self.scip_node) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_node == (other).scip_node) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_31__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_31__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_30__eq__(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_30__eq__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "src/pyscipopt/scip.pxi":801 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_node == (other).scip_node) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "src/pyscipopt/scip.pxi":802 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_node == (other).scip_node) # <<<<<<<<<<<<<< + * + * cdef class Variable(Expr): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 801, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":801 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_node == (other).scip_node) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 801, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 801, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 801, __pyx_L1_error) + if (__pyx_t_5) { + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "src/pyscipopt/scip.pxi":802 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_node == (other).scip_node) # <<<<<<<<<<<<<< + * + * cdef class Variable(Expr): + */ + __pyx_t_5 = (__pyx_v_self->scip_node == ((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_other)->scip_node); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 802, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":800 + * return hash(self.scip_node) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_node == (other).scip_node) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Node.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1924 + * cdef SCIP_NODE* scip_node + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * + * @staticmethod + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Node_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Node_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Node_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_4Node_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_4Node_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_4Node_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_33__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_32__reduce_cython__, "Node.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_33__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_33__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_32__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_33__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_32__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_32__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_node_cannot_be_convert, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Node.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_35__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_4Node_34__setstate_cython__, "Node.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_4Node_35__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_35__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_34__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_4Node_35__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Node.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_4Node_34__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Node *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_4Node_34__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_node_cannot_be_convert, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Node.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":808 + * + * @staticmethod + * cdef create(SCIP_VAR* scipvar): # <<<<<<<<<<<<<< + * if scipvar == NULL: + * raise Warning("cannot create Variable with SCIP_VAR* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_8Variable_create(SCIP_VAR *__pyx_v_scipvar) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":809 + * @staticmethod + * cdef create(SCIP_VAR* scipvar): + * if scipvar == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Variable with SCIP_VAR* == NULL") + * var = Variable() + */ + __pyx_t_1 = (__pyx_v_scipvar == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":810 + * cdef create(SCIP_VAR* scipvar): + * if scipvar == NULL: + * raise Warning("cannot create Variable with SCIP_VAR* == NULL") # <<<<<<<<<<<<<< + * var = Variable() + * var.scip_var = scipvar + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 810, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":809 + * @staticmethod + * cdef create(SCIP_VAR* scipvar): + * if scipvar == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Variable with SCIP_VAR* == NULL") + * var = Variable() + */ + } + + /* "src/pyscipopt/scip.pxi":811 + * if scipvar == NULL: + * raise Warning("cannot create Variable with SCIP_VAR* == NULL") + * var = Variable() # <<<<<<<<<<<<<< + * var.scip_var = scipvar + * Expr.__init__(var, {Term(var) : 1.0}) + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 811, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":812 + * raise Warning("cannot create Variable with SCIP_VAR* == NULL") + * var = Variable() + * var.scip_var = scipvar # <<<<<<<<<<<<<< + * Expr.__init__(var, {Term(var) : 1.0}) + * return var + */ + __pyx_v_var->scip_var = __pyx_v_scipvar; + + /* "src/pyscipopt/scip.pxi":813 + * var = Variable() + * var.scip_var = scipvar + * Expr.__init__(var, {Term(var) : 1.0}) # <<<<<<<<<<<<<< + * return var + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr), __pyx_n_s_init); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_Term); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, ((PyObject *)__pyx_v_var)}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + if (PyDict_SetItem(__pyx_t_4, __pyx_t_5, __pyx_float_1_0) < 0) __PYX_ERR(0, 813, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, ((PyObject *)__pyx_v_var), __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_8, 2+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":814 + * var.scip_var = scipvar + * Expr.__init__(var, {Term(var) : 1.0}) + * return var # <<<<<<<<<<<<<< + * + * property name: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_var); + __pyx_r = ((PyObject *)__pyx_v_var); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":808 + * + * @staticmethod + * cdef create(SCIP_VAR* scipvar): # <<<<<<<<<<<<<< + * if scipvar == NULL: + * raise Warning("cannot create Variable with SCIP_VAR* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Variable.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":817 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * cname = bytes( SCIPvarGetName(self.scip_var) ) + * return cname.decode('utf-8') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_v_cname = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "src/pyscipopt/scip.pxi":818 + * property name: + * def __get__(self): + * cname = bytes( SCIPvarGetName(self.scip_var) ) # <<<<<<<<<<<<<< + * return cname.decode('utf-8') + * + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPvarGetName(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 818, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 818, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_cname = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":819 + * def __get__(self): + * cname = bytes( SCIPvarGetName(self.scip_var) ) + * return cname.decode('utf-8') # <<<<<<<<<<<<<< + * + * def ptr(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_decode_bytes(__pyx_v_cname, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":817 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * cname = bytes( SCIPvarGetName(self.scip_var) ) + * return cname.decode('utf-8') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Variable.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_cname); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":821 + * return cname.decode('utf-8') + * + * def ptr(self): # <<<<<<<<<<<<<< + * """ """ + * return (self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_1ptr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_ptr, "Variable.ptr(self)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_1ptr = {"ptr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_1ptr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_ptr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_1ptr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ptr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("ptr", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "ptr", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_ptr(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_ptr(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ptr", 1); + + /* "src/pyscipopt/scip.pxi":823 + * def ptr(self): + * """ """ + * return (self.scip_var) # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 823, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":821 + * return cname.decode('utf-8') + * + * def ptr(self): # <<<<<<<<<<<<<< + * """ """ + * return (self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.ptr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":825 + * return (self.scip_var) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_2__repr__(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_2__repr__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/scip.pxi":826 + * + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * def vtype(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":825 + * return (self.scip_var) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":828 + * return self.name + * + * def vtype(self): # <<<<<<<<<<<<<< + * """Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)""" + * vartype = SCIPvarGetType(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_5vtype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_4vtype, "Variable.vtype(self)\nRetrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_5vtype = {"vtype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_5vtype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_4vtype}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_5vtype(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("vtype (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("vtype", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "vtype", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_4vtype(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_4vtype(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + SCIP_VARTYPE __pyx_v_vartype; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("vtype", 1); + + /* "src/pyscipopt/scip.pxi":830 + * def vtype(self): + * """Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)""" + * vartype = SCIPvarGetType(self.scip_var) # <<<<<<<<<<<<<< + * if vartype == SCIP_VARTYPE_BINARY: + * return "BINARY" + */ + __pyx_v_vartype = SCIPvarGetType(__pyx_v_self->scip_var); + + /* "src/pyscipopt/scip.pxi":831 + * """Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)""" + * vartype = SCIPvarGetType(self.scip_var) + * if vartype == SCIP_VARTYPE_BINARY: # <<<<<<<<<<<<<< + * return "BINARY" + * elif vartype == SCIP_VARTYPE_INTEGER: + */ + __pyx_t_1 = (__pyx_v_vartype == SCIP_VARTYPE_BINARY); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":832 + * vartype = SCIPvarGetType(self.scip_var) + * if vartype == SCIP_VARTYPE_BINARY: + * return "BINARY" # <<<<<<<<<<<<<< + * elif vartype == SCIP_VARTYPE_INTEGER: + * return "INTEGER" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_BINARY); + __pyx_r = __pyx_n_u_BINARY; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":831 + * """Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)""" + * vartype = SCIPvarGetType(self.scip_var) + * if vartype == SCIP_VARTYPE_BINARY: # <<<<<<<<<<<<<< + * return "BINARY" + * elif vartype == SCIP_VARTYPE_INTEGER: + */ + } + + /* "src/pyscipopt/scip.pxi":833 + * if vartype == SCIP_VARTYPE_BINARY: + * return "BINARY" + * elif vartype == SCIP_VARTYPE_INTEGER: # <<<<<<<<<<<<<< + * return "INTEGER" + * elif vartype == SCIP_VARTYPE_CONTINUOUS: + */ + __pyx_t_1 = (__pyx_v_vartype == SCIP_VARTYPE_INTEGER); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":834 + * return "BINARY" + * elif vartype == SCIP_VARTYPE_INTEGER: + * return "INTEGER" # <<<<<<<<<<<<<< + * elif vartype == SCIP_VARTYPE_CONTINUOUS: + * return "CONTINUOUS" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_INTEGER); + __pyx_r = __pyx_n_u_INTEGER; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":833 + * if vartype == SCIP_VARTYPE_BINARY: + * return "BINARY" + * elif vartype == SCIP_VARTYPE_INTEGER: # <<<<<<<<<<<<<< + * return "INTEGER" + * elif vartype == SCIP_VARTYPE_CONTINUOUS: + */ + } + + /* "src/pyscipopt/scip.pxi":835 + * elif vartype == SCIP_VARTYPE_INTEGER: + * return "INTEGER" + * elif vartype == SCIP_VARTYPE_CONTINUOUS: # <<<<<<<<<<<<<< + * return "CONTINUOUS" + * elif vartype == SCIP_VARTYPE_IMPLINT: + */ + __pyx_t_1 = (__pyx_v_vartype == SCIP_VARTYPE_CONTINUOUS); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":836 + * return "INTEGER" + * elif vartype == SCIP_VARTYPE_CONTINUOUS: + * return "CONTINUOUS" # <<<<<<<<<<<<<< + * elif vartype == SCIP_VARTYPE_IMPLINT: + * return "IMPLINT" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_CONTINUOUS); + __pyx_r = __pyx_n_u_CONTINUOUS; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":835 + * elif vartype == SCIP_VARTYPE_INTEGER: + * return "INTEGER" + * elif vartype == SCIP_VARTYPE_CONTINUOUS: # <<<<<<<<<<<<<< + * return "CONTINUOUS" + * elif vartype == SCIP_VARTYPE_IMPLINT: + */ + } + + /* "src/pyscipopt/scip.pxi":837 + * elif vartype == SCIP_VARTYPE_CONTINUOUS: + * return "CONTINUOUS" + * elif vartype == SCIP_VARTYPE_IMPLINT: # <<<<<<<<<<<<<< + * return "IMPLINT" + * + */ + __pyx_t_1 = (__pyx_v_vartype == SCIP_VARTYPE_IMPLINT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":838 + * return "CONTINUOUS" + * elif vartype == SCIP_VARTYPE_IMPLINT: + * return "IMPLINT" # <<<<<<<<<<<<<< + * + * def isOriginal(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_IMPLINT); + __pyx_r = __pyx_n_u_IMPLINT; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":837 + * elif vartype == SCIP_VARTYPE_CONTINUOUS: + * return "CONTINUOUS" + * elif vartype == SCIP_VARTYPE_IMPLINT: # <<<<<<<<<<<<<< + * return "IMPLINT" + * + */ + } + + /* "src/pyscipopt/scip.pxi":828 + * return self.name + * + * def vtype(self): # <<<<<<<<<<<<<< + * """Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)""" + * vartype = SCIPvarGetType(self.scip_var) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":840 + * return "IMPLINT" + * + * def isOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve whether the variable belongs to the original problem""" + * return SCIPvarIsOriginal(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_7isOriginal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_6isOriginal, "Variable.isOriginal(self)\nRetrieve whether the variable belongs to the original problem"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_7isOriginal = {"isOriginal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_7isOriginal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_6isOriginal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_7isOriginal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isOriginal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isOriginal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isOriginal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_6isOriginal(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_6isOriginal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isOriginal", 1); + + /* "src/pyscipopt/scip.pxi":842 + * def isOriginal(self): + * """Retrieve whether the variable belongs to the original problem""" + * return SCIPvarIsOriginal(self.scip_var) # <<<<<<<<<<<<<< + * + * def isInLP(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPvarIsOriginal(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 842, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":840 + * return "IMPLINT" + * + * def isOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve whether the variable belongs to the original problem""" + * return SCIPvarIsOriginal(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.isOriginal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":844 + * return SCIPvarIsOriginal(self.scip_var) + * + * def isInLP(self): # <<<<<<<<<<<<<< + * """Retrieve whether the variable is a COLUMN variable that is member of the current LP""" + * return SCIPvarIsInLP(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_9isInLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_8isInLP, "Variable.isInLP(self)\nRetrieve whether the variable is a COLUMN variable that is member of the current LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_9isInLP = {"isInLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_9isInLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_8isInLP}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_9isInLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isInLP (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isInLP", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isInLP", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_8isInLP(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_8isInLP(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isInLP", 1); + + /* "src/pyscipopt/scip.pxi":846 + * def isInLP(self): + * """Retrieve whether the variable is a COLUMN variable that is member of the current LP""" + * return SCIPvarIsInLP(self.scip_var) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPvarIsInLP(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 846, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":844 + * return SCIPvarIsOriginal(self.scip_var) + * + * def isInLP(self): # <<<<<<<<<<<<<< + * """Retrieve whether the variable is a COLUMN variable that is member of the current LP""" + * return SCIPvarIsInLP(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.isInLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":849 + * + * + * def getIndex(self): # <<<<<<<<<<<<<< + * """Retrieve the unique index of the variable.""" + * return SCIPvarGetIndex(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_11getIndex(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_10getIndex, "Variable.getIndex(self)\nRetrieve the unique index of the variable."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_11getIndex = {"getIndex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_11getIndex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_10getIndex}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_11getIndex(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getIndex (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getIndex", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getIndex", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_10getIndex(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_10getIndex(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getIndex", 1); + + /* "src/pyscipopt/scip.pxi":851 + * def getIndex(self): + * """Retrieve the unique index of the variable.""" + * return SCIPvarGetIndex(self.scip_var) # <<<<<<<<<<<<<< + * + * def getCol(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPvarGetIndex(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":849 + * + * + * def getIndex(self): # <<<<<<<<<<<<<< + * """Retrieve the unique index of the variable.""" + * return SCIPvarGetIndex(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getIndex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":853 + * return SCIPvarGetIndex(self.scip_var) + * + * def getCol(self): # <<<<<<<<<<<<<< + * """Retrieve column of COLUMN variable""" + * cdef SCIP_COL* scip_col + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_13getCol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_12getCol, "Variable.getCol(self)\nRetrieve column of COLUMN variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_13getCol = {"getCol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_13getCol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_12getCol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_13getCol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getCol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getCol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_12getCol(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_12getCol(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + SCIP_COL *__pyx_v_scip_col; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getCol", 1); + + /* "src/pyscipopt/scip.pxi":856 + * """Retrieve column of COLUMN variable""" + * cdef SCIP_COL* scip_col + * scip_col = SCIPvarGetCol(self.scip_var) # <<<<<<<<<<<<<< + * return Column.create(scip_col) + * + */ + __pyx_v_scip_col = SCIPvarGetCol(__pyx_v_self->scip_var); + + /* "src/pyscipopt/scip.pxi":857 + * cdef SCIP_COL* scip_col + * scip_col = SCIPvarGetCol(self.scip_var) + * return Column.create(scip_col) # <<<<<<<<<<<<<< + * + * def getLbOriginal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_6Column_create(__pyx_v_scip_col); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 857, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":853 + * return SCIPvarGetIndex(self.scip_var) + * + * def getCol(self): # <<<<<<<<<<<<<< + * """Retrieve column of COLUMN variable""" + * cdef SCIP_COL* scip_col + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getCol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":859 + * return Column.create(scip_col) + * + * def getLbOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve original lower bound of variable""" + * return SCIPvarGetLbOriginal(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_15getLbOriginal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_14getLbOriginal, "Variable.getLbOriginal(self)\nRetrieve original lower bound of variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_15getLbOriginal = {"getLbOriginal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_15getLbOriginal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_14getLbOriginal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_15getLbOriginal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLbOriginal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLbOriginal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLbOriginal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_14getLbOriginal(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_14getLbOriginal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLbOriginal", 1); + + /* "src/pyscipopt/scip.pxi":861 + * def getLbOriginal(self): + * """Retrieve original lower bound of variable""" + * return SCIPvarGetLbOriginal(self.scip_var) # <<<<<<<<<<<<<< + * + * def getUbOriginal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPvarGetLbOriginal(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 861, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":859 + * return Column.create(scip_col) + * + * def getLbOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve original lower bound of variable""" + * return SCIPvarGetLbOriginal(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getLbOriginal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":863 + * return SCIPvarGetLbOriginal(self.scip_var) + * + * def getUbOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve original upper bound of variable""" + * return SCIPvarGetUbOriginal(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_17getUbOriginal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_16getUbOriginal, "Variable.getUbOriginal(self)\nRetrieve original upper bound of variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_17getUbOriginal = {"getUbOriginal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_17getUbOriginal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_16getUbOriginal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_17getUbOriginal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getUbOriginal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getUbOriginal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getUbOriginal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_16getUbOriginal(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_16getUbOriginal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getUbOriginal", 1); + + /* "src/pyscipopt/scip.pxi":865 + * def getUbOriginal(self): + * """Retrieve original upper bound of variable""" + * return SCIPvarGetUbOriginal(self.scip_var) # <<<<<<<<<<<<<< + * + * def getLbGlobal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPvarGetUbOriginal(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":863 + * return SCIPvarGetLbOriginal(self.scip_var) + * + * def getUbOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve original upper bound of variable""" + * return SCIPvarGetUbOriginal(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getUbOriginal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":867 + * return SCIPvarGetUbOriginal(self.scip_var) + * + * def getLbGlobal(self): # <<<<<<<<<<<<<< + * """Retrieve global lower bound of variable""" + * return SCIPvarGetLbGlobal(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_19getLbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_18getLbGlobal, "Variable.getLbGlobal(self)\nRetrieve global lower bound of variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_19getLbGlobal = {"getLbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_19getLbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_18getLbGlobal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_19getLbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLbGlobal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLbGlobal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLbGlobal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_18getLbGlobal(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_18getLbGlobal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLbGlobal", 1); + + /* "src/pyscipopt/scip.pxi":869 + * def getLbGlobal(self): + * """Retrieve global lower bound of variable""" + * return SCIPvarGetLbGlobal(self.scip_var) # <<<<<<<<<<<<<< + * + * def getUbGlobal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPvarGetLbGlobal(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":867 + * return SCIPvarGetUbOriginal(self.scip_var) + * + * def getLbGlobal(self): # <<<<<<<<<<<<<< + * """Retrieve global lower bound of variable""" + * return SCIPvarGetLbGlobal(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getLbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":871 + * return SCIPvarGetLbGlobal(self.scip_var) + * + * def getUbGlobal(self): # <<<<<<<<<<<<<< + * """Retrieve global upper bound of variable""" + * return SCIPvarGetUbGlobal(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_21getUbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_20getUbGlobal, "Variable.getUbGlobal(self)\nRetrieve global upper bound of variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_21getUbGlobal = {"getUbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_21getUbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_20getUbGlobal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_21getUbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getUbGlobal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getUbGlobal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getUbGlobal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_20getUbGlobal(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_20getUbGlobal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getUbGlobal", 1); + + /* "src/pyscipopt/scip.pxi":873 + * def getUbGlobal(self): + * """Retrieve global upper bound of variable""" + * return SCIPvarGetUbGlobal(self.scip_var) # <<<<<<<<<<<<<< + * + * def getLbLocal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPvarGetUbGlobal(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 873, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":871 + * return SCIPvarGetLbGlobal(self.scip_var) + * + * def getUbGlobal(self): # <<<<<<<<<<<<<< + * """Retrieve global upper bound of variable""" + * return SCIPvarGetUbGlobal(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getUbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":875 + * return SCIPvarGetUbGlobal(self.scip_var) + * + * def getLbLocal(self): # <<<<<<<<<<<<<< + * """Retrieve current lower bound of variable""" + * return SCIPvarGetLbLocal(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_23getLbLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_22getLbLocal, "Variable.getLbLocal(self)\nRetrieve current lower bound of variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_23getLbLocal = {"getLbLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_23getLbLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_22getLbLocal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_23getLbLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLbLocal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLbLocal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLbLocal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_22getLbLocal(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_22getLbLocal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLbLocal", 1); + + /* "src/pyscipopt/scip.pxi":877 + * def getLbLocal(self): + * """Retrieve current lower bound of variable""" + * return SCIPvarGetLbLocal(self.scip_var) # <<<<<<<<<<<<<< + * + * def getUbLocal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPvarGetLbLocal(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 877, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":875 + * return SCIPvarGetUbGlobal(self.scip_var) + * + * def getLbLocal(self): # <<<<<<<<<<<<<< + * """Retrieve current lower bound of variable""" + * return SCIPvarGetLbLocal(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getLbLocal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":879 + * return SCIPvarGetLbLocal(self.scip_var) + * + * def getUbLocal(self): # <<<<<<<<<<<<<< + * """Retrieve current upper bound of variable""" + * return SCIPvarGetUbLocal(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_25getUbLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_24getUbLocal, "Variable.getUbLocal(self)\nRetrieve current upper bound of variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_25getUbLocal = {"getUbLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_25getUbLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_24getUbLocal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_25getUbLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getUbLocal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getUbLocal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getUbLocal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_24getUbLocal(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_24getUbLocal(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getUbLocal", 1); + + /* "src/pyscipopt/scip.pxi":881 + * def getUbLocal(self): + * """Retrieve current upper bound of variable""" + * return SCIPvarGetUbLocal(self.scip_var) # <<<<<<<<<<<<<< + * + * def getObj(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPvarGetUbLocal(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 881, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":879 + * return SCIPvarGetLbLocal(self.scip_var) + * + * def getUbLocal(self): # <<<<<<<<<<<<<< + * """Retrieve current upper bound of variable""" + * return SCIPvarGetUbLocal(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getUbLocal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":883 + * return SCIPvarGetUbLocal(self.scip_var) + * + * def getObj(self): # <<<<<<<<<<<<<< + * """Retrieve current objective value of variable""" + * return SCIPvarGetObj(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_27getObj(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_26getObj, "Variable.getObj(self)\nRetrieve current objective value of variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_27getObj = {"getObj", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_27getObj, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_26getObj}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_27getObj(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getObj (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getObj", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getObj", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_26getObj(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_26getObj(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getObj", 1); + + /* "src/pyscipopt/scip.pxi":885 + * def getObj(self): + * """Retrieve current objective value of variable""" + * return SCIPvarGetObj(self.scip_var) # <<<<<<<<<<<<<< + * + * def getLPSol(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPvarGetObj(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":883 + * return SCIPvarGetUbLocal(self.scip_var) + * + * def getObj(self): # <<<<<<<<<<<<<< + * """Retrieve current objective value of variable""" + * return SCIPvarGetObj(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getObj", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":887 + * return SCIPvarGetObj(self.scip_var) + * + * def getLPSol(self): # <<<<<<<<<<<<<< + * """Retrieve the current LP solution value of variable""" + * return SCIPvarGetLPSol(self.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_29getLPSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_28getLPSol, "Variable.getLPSol(self)\nRetrieve the current LP solution value of variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_29getLPSol = {"getLPSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_29getLPSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_28getLPSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_29getLPSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPSol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPSol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_28getLPSol(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_28getLPSol(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPSol", 1); + + /* "src/pyscipopt/scip.pxi":889 + * def getLPSol(self): + * """Retrieve the current LP solution value of variable""" + * return SCIPvarGetLPSol(self.scip_var) # <<<<<<<<<<<<<< + * + * cdef class Constraint: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPvarGetLPSol(__pyx_v_self->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":887 + * return SCIPvarGetObj(self.scip_var) + * + * def getLPSol(self): # <<<<<<<<<<<<<< + * """Retrieve the current LP solution value of variable""" + * return SCIPvarGetLPSol(self.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Variable.getLPSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1932 + * cdef SCIP_VAR* scip_var + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * + * @staticmethod + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Variable_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Variable_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Variable_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_8Variable_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_8Variable_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_8Variable_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_31__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_30__reduce_cython__, "Variable.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_31__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_31__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_30__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_31__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_30__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_30__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_var_cannot_be_converte, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Variable.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_33__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_8Variable_32__setstate_cython__, "Variable.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_8Variable_33__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_33__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_32__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_8Variable_33__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Variable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_8Variable_32__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_8Variable_32__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_var_cannot_be_converte, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Variable.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":895 + * + * @staticmethod + * cdef create(SCIP_CONS* scipcons): # <<<<<<<<<<<<<< + * if scipcons == NULL: + * raise Warning("cannot create Constraint with SCIP_CONS* == NULL") + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_10Constraint_create(SCIP_CONS *__pyx_v_scipcons) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":896 + * @staticmethod + * cdef create(SCIP_CONS* scipcons): + * if scipcons == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Constraint with SCIP_CONS* == NULL") + * cons = Constraint() + */ + __pyx_t_1 = (__pyx_v_scipcons == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":897 + * cdef create(SCIP_CONS* scipcons): + * if scipcons == NULL: + * raise Warning("cannot create Constraint with SCIP_CONS* == NULL") # <<<<<<<<<<<<<< + * cons = Constraint() + * cons.scip_cons = scipcons + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 897, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":896 + * @staticmethod + * cdef create(SCIP_CONS* scipcons): + * if scipcons == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Constraint with SCIP_CONS* == NULL") + * cons = Constraint() + */ + } + + /* "src/pyscipopt/scip.pxi":898 + * if scipcons == NULL: + * raise Warning("cannot create Constraint with SCIP_CONS* == NULL") + * cons = Constraint() # <<<<<<<<<<<<<< + * cons.scip_cons = scipcons + * return cons + */ + __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 898, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":899 + * raise Warning("cannot create Constraint with SCIP_CONS* == NULL") + * cons = Constraint() + * cons.scip_cons = scipcons # <<<<<<<<<<<<<< + * return cons + * + */ + __pyx_v_cons->scip_cons = __pyx_v_scipcons; + + /* "src/pyscipopt/scip.pxi":900 + * cons = Constraint() + * cons.scip_cons = scipcons + * return cons # <<<<<<<<<<<<<< + * + * property name: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_cons); + __pyx_r = ((PyObject *)__pyx_v_cons); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":895 + * + * @staticmethod + * cdef create(SCIP_CONS* scipcons): # <<<<<<<<<<<<<< + * if scipcons == NULL: + * raise Warning("cannot create Constraint with SCIP_CONS* == NULL") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_cons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":903 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * cname = bytes( SCIPconsGetName(self.scip_cons) ) + * return cname.decode('utf-8') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_4name___get__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_4name___get__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_v_cname = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "src/pyscipopt/scip.pxi":904 + * property name: + * def __get__(self): + * cname = bytes( SCIPconsGetName(self.scip_cons) ) # <<<<<<<<<<<<<< + * return cname.decode('utf-8') + * + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconsGetName(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 904, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 904, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_cname = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":905 + * def __get__(self): + * cname = bytes( SCIPconsGetName(self.scip_cons) ) + * return cname.decode('utf-8') # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_decode_bytes(__pyx_v_cname, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 905, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":903 + * + * property name: + * def __get__(self): # <<<<<<<<<<<<<< + * cname = bytes( SCIPconsGetName(self.scip_cons) ) + * return cname.decode('utf-8') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_cname); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":907 + * return cname.decode('utf-8') + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_1__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_1__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint___repr__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint___repr__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 1); + + /* "src/pyscipopt/scip.pxi":908 + * + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * def isOriginal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 908, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":907 + * return cname.decode('utf-8') + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":910 + * return self.name + * + * def isOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve whether the constraint belongs to the original problem""" + * return SCIPconsIsOriginal(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_3isOriginal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_2isOriginal, "Constraint.isOriginal(self)\nRetrieve whether the constraint belongs to the original problem"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_3isOriginal = {"isOriginal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_3isOriginal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_2isOriginal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_3isOriginal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isOriginal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isOriginal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isOriginal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_2isOriginal(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_2isOriginal(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isOriginal", 1); + + /* "src/pyscipopt/scip.pxi":912 + * def isOriginal(self): + * """Retrieve whether the constraint belongs to the original problem""" + * return SCIPconsIsOriginal(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isInitial(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsOriginal(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":910 + * return self.name + * + * def isOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve whether the constraint belongs to the original problem""" + * return SCIPconsIsOriginal(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isOriginal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":914 + * return SCIPconsIsOriginal(self.scip_cons) + * + * def isInitial(self): # <<<<<<<<<<<<<< + * """Retrieve True if the relaxation of the constraint should be in the initial LP""" + * return SCIPconsIsInitial(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_5isInitial(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_4isInitial, "Constraint.isInitial(self)\nRetrieve True if the relaxation of the constraint should be in the initial LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_5isInitial = {"isInitial", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_5isInitial, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_4isInitial}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_5isInitial(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isInitial (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isInitial", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isInitial", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_4isInitial(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_4isInitial(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isInitial", 1); + + /* "src/pyscipopt/scip.pxi":916 + * def isInitial(self): + * """Retrieve True if the relaxation of the constraint should be in the initial LP""" + * return SCIPconsIsInitial(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isSeparated(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsInitial(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":914 + * return SCIPconsIsOriginal(self.scip_cons) + * + * def isInitial(self): # <<<<<<<<<<<<<< + * """Retrieve True if the relaxation of the constraint should be in the initial LP""" + * return SCIPconsIsInitial(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isInitial", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":918 + * return SCIPconsIsInitial(self.scip_cons) + * + * def isSeparated(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be separated during LP processing""" + * return SCIPconsIsSeparated(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_7isSeparated(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_6isSeparated, "Constraint.isSeparated(self)\nRetrieve True if constraint should be separated during LP processing"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_7isSeparated = {"isSeparated", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_7isSeparated, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_6isSeparated}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_7isSeparated(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isSeparated (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isSeparated", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isSeparated", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_6isSeparated(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_6isSeparated(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isSeparated", 1); + + /* "src/pyscipopt/scip.pxi":920 + * def isSeparated(self): + * """Retrieve True if constraint should be separated during LP processing""" + * return SCIPconsIsSeparated(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isEnforced(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsSeparated(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":918 + * return SCIPconsIsInitial(self.scip_cons) + * + * def isSeparated(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be separated during LP processing""" + * return SCIPconsIsSeparated(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isSeparated", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":922 + * return SCIPconsIsSeparated(self.scip_cons) + * + * def isEnforced(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be enforced during node processing""" + * return SCIPconsIsEnforced(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_9isEnforced(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_8isEnforced, "Constraint.isEnforced(self)\nRetrieve True if constraint should be enforced during node processing"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_9isEnforced = {"isEnforced", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_9isEnforced, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_8isEnforced}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_9isEnforced(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isEnforced (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isEnforced", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isEnforced", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_8isEnforced(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_8isEnforced(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isEnforced", 1); + + /* "src/pyscipopt/scip.pxi":924 + * def isEnforced(self): + * """Retrieve True if constraint should be enforced during node processing""" + * return SCIPconsIsEnforced(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isChecked(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsEnforced(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":922 + * return SCIPconsIsSeparated(self.scip_cons) + * + * def isEnforced(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be enforced during node processing""" + * return SCIPconsIsEnforced(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isEnforced", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":926 + * return SCIPconsIsEnforced(self.scip_cons) + * + * def isChecked(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be checked for feasibility""" + * return SCIPconsIsChecked(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_11isChecked(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_10isChecked, "Constraint.isChecked(self)\nRetrieve True if constraint should be checked for feasibility"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_11isChecked = {"isChecked", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_11isChecked, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_10isChecked}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_11isChecked(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isChecked (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isChecked", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isChecked", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_10isChecked(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_10isChecked(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isChecked", 1); + + /* "src/pyscipopt/scip.pxi":928 + * def isChecked(self): + * """Retrieve True if constraint should be checked for feasibility""" + * return SCIPconsIsChecked(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isPropagated(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsChecked(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":926 + * return SCIPconsIsEnforced(self.scip_cons) + * + * def isChecked(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be checked for feasibility""" + * return SCIPconsIsChecked(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isChecked", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":930 + * return SCIPconsIsChecked(self.scip_cons) + * + * def isPropagated(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be propagated during node processing""" + * return SCIPconsIsPropagated(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_13isPropagated(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_12isPropagated, "Constraint.isPropagated(self)\nRetrieve True if constraint should be propagated during node processing"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_13isPropagated = {"isPropagated", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_13isPropagated, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_12isPropagated}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_13isPropagated(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isPropagated (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isPropagated", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isPropagated", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_12isPropagated(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_12isPropagated(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isPropagated", 1); + + /* "src/pyscipopt/scip.pxi":932 + * def isPropagated(self): + * """Retrieve True if constraint should be propagated during node processing""" + * return SCIPconsIsPropagated(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isLocal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsPropagated(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 932, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":930 + * return SCIPconsIsChecked(self.scip_cons) + * + * def isPropagated(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be propagated during node processing""" + * return SCIPconsIsPropagated(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isPropagated", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":934 + * return SCIPconsIsPropagated(self.scip_cons) + * + * def isLocal(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is only locally valid or not added to any (sub)problem""" + * return SCIPconsIsLocal(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_15isLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_14isLocal, "Constraint.isLocal(self)\nRetrieve True if constraint is only locally valid or not added to any (sub)problem"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_15isLocal = {"isLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_15isLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_14isLocal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_15isLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isLocal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isLocal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isLocal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_14isLocal(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_14isLocal(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isLocal", 1); + + /* "src/pyscipopt/scip.pxi":936 + * def isLocal(self): + * """Retrieve True if constraint is only locally valid or not added to any (sub)problem""" + * return SCIPconsIsLocal(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isModifiable(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsLocal(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 936, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":934 + * return SCIPconsIsPropagated(self.scip_cons) + * + * def isLocal(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is only locally valid or not added to any (sub)problem""" + * return SCIPconsIsLocal(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isLocal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":938 + * return SCIPconsIsLocal(self.scip_cons) + * + * def isModifiable(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is modifiable (subject to column generation)""" + * return SCIPconsIsModifiable(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_17isModifiable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_16isModifiable, "Constraint.isModifiable(self)\nRetrieve True if constraint is modifiable (subject to column generation)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_17isModifiable = {"isModifiable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_17isModifiable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_16isModifiable}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_17isModifiable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isModifiable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isModifiable", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isModifiable", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_16isModifiable(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_16isModifiable(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isModifiable", 1); + + /* "src/pyscipopt/scip.pxi":940 + * def isModifiable(self): + * """Retrieve True if constraint is modifiable (subject to column generation)""" + * return SCIPconsIsModifiable(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isDynamic(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsModifiable(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 940, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":938 + * return SCIPconsIsLocal(self.scip_cons) + * + * def isModifiable(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is modifiable (subject to column generation)""" + * return SCIPconsIsModifiable(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isModifiable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":942 + * return SCIPconsIsModifiable(self.scip_cons) + * + * def isDynamic(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is subject to aging""" + * return SCIPconsIsDynamic(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_19isDynamic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_18isDynamic, "Constraint.isDynamic(self)\nRetrieve True if constraint is subject to aging"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_19isDynamic = {"isDynamic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_19isDynamic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_18isDynamic}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_19isDynamic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isDynamic (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isDynamic", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isDynamic", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_18isDynamic(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_18isDynamic(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isDynamic", 1); + + /* "src/pyscipopt/scip.pxi":944 + * def isDynamic(self): + * """Retrieve True if constraint is subject to aging""" + * return SCIPconsIsDynamic(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isRemovable(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsDynamic(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":942 + * return SCIPconsIsModifiable(self.scip_cons) + * + * def isDynamic(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is subject to aging""" + * return SCIPconsIsDynamic(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isDynamic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":946 + * return SCIPconsIsDynamic(self.scip_cons) + * + * def isRemovable(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint's relaxation should be removed from the LP due to aging or cleanup""" + * return SCIPconsIsRemovable(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_21isRemovable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_20isRemovable, "Constraint.isRemovable(self)\nRetrieve True if constraint's relaxation should be removed from the LP due to aging or cleanup"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_21isRemovable = {"isRemovable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_21isRemovable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_20isRemovable}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_21isRemovable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isRemovable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isRemovable", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isRemovable", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_20isRemovable(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_20isRemovable(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isRemovable", 1); + + /* "src/pyscipopt/scip.pxi":948 + * def isRemovable(self): + * """Retrieve True if constraint's relaxation should be removed from the LP due to aging or cleanup""" + * return SCIPconsIsRemovable(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isStickingAtNode(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsRemovable(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":946 + * return SCIPconsIsDynamic(self.scip_cons) + * + * def isRemovable(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint's relaxation should be removed from the LP due to aging or cleanup""" + * return SCIPconsIsRemovable(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isRemovable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":950 + * return SCIPconsIsRemovable(self.scip_cons) + * + * def isStickingAtNode(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is only locally valid or not added to any (sub)problem""" + * return SCIPconsIsStickingAtNode(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_23isStickingAtNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_22isStickingAtNode, "Constraint.isStickingAtNode(self)\nRetrieve True if constraint is only locally valid or not added to any (sub)problem"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_23isStickingAtNode = {"isStickingAtNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_23isStickingAtNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_22isStickingAtNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_23isStickingAtNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isStickingAtNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isStickingAtNode", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isStickingAtNode", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_22isStickingAtNode(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_22isStickingAtNode(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isStickingAtNode", 1); + + /* "src/pyscipopt/scip.pxi":952 + * def isStickingAtNode(self): + * """Retrieve True if constraint is only locally valid or not added to any (sub)problem""" + * return SCIPconsIsStickingAtNode(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isActive(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsStickingAtNode(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":950 + * return SCIPconsIsRemovable(self.scip_cons) + * + * def isStickingAtNode(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is only locally valid or not added to any (sub)problem""" + * return SCIPconsIsStickingAtNode(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isStickingAtNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":954 + * return SCIPconsIsStickingAtNode(self.scip_cons) + * + * def isActive(self): # <<<<<<<<<<<<<< + * """returns True iff constraint is active in the current node""" + * return SCIPconsIsActive(self.scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_25isActive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_24isActive, "Constraint.isActive(self)\nreturns True iff constraint is active in the current node"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_25isActive = {"isActive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_25isActive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_24isActive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_25isActive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isActive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isActive", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isActive", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_24isActive(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_24isActive(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isActive", 1); + + /* "src/pyscipopt/scip.pxi":956 + * def isActive(self): + * """returns True iff constraint is active in the current node""" + * return SCIPconsIsActive(self.scip_cons) # <<<<<<<<<<<<<< + * + * def isLinear(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPconsIsActive(__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":954 + * return SCIPconsIsStickingAtNode(self.scip_cons) + * + * def isActive(self): # <<<<<<<<<<<<<< + * """returns True iff constraint is active in the current node""" + * return SCIPconsIsActive(self.scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isActive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":958 + * return SCIPconsIsActive(self.scip_cons) + * + * def isLinear(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is linear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_27isLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_26isLinear, "Constraint.isLinear(self)\nRetrieve True if constraint is linear"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_27isLinear = {"isLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_27isLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_26isLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_27isLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isLinear", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isLinear", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_26isLinear(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_26isLinear(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isLinear", 1); + + /* "src/pyscipopt/scip.pxi":960 + * def isLinear(self): + * """Retrieve True if constraint is linear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * return constype == 'linear' + * + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_self->scip_cons))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":961 + * """Retrieve True if constraint is linear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + * return constype == 'linear' # <<<<<<<<<<<<<< + * + * def isNonlinear(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyObject_RichCompare(__pyx_v_constype, __pyx_n_u_linear, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 961, __pyx_L1_error) + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":958 + * return SCIPconsIsActive(self.scip_cons) + * + * def isLinear(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is linear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":963 + * return constype == 'linear' + * + * def isNonlinear(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is nonlinear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_29isNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_28isNonlinear, "Constraint.isNonlinear(self)\nRetrieve True if constraint is nonlinear"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_29isNonlinear = {"isNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_29isNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_28isNonlinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_29isNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isNonlinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isNonlinear", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isNonlinear", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_28isNonlinear(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_28isNonlinear(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isNonlinear", 1); + + /* "src/pyscipopt/scip.pxi":965 + * def isNonlinear(self): + * """Retrieve True if constraint is nonlinear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * return constype == 'nonlinear' + * + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_self->scip_cons))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":966 + * """Retrieve True if constraint is nonlinear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + * return constype == 'nonlinear' # <<<<<<<<<<<<<< + * + * def getConshdlrName(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyObject_RichCompare(__pyx_v_constype, __pyx_n_u_nonlinear, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 966, __pyx_L1_error) + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":963 + * return constype == 'linear' + * + * def isNonlinear(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is nonlinear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.isNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":968 + * return constype == 'nonlinear' + * + * def getConshdlrName(self): # <<<<<<<<<<<<<< + * """Return the constraint handler's name""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_31getConshdlrName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_30getConshdlrName, "Constraint.getConshdlrName(self)\nReturn the constraint handler's name"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_31getConshdlrName = {"getConshdlrName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_31getConshdlrName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_30getConshdlrName}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_31getConshdlrName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getConshdlrName (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getConshdlrName", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getConshdlrName", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_30getConshdlrName(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_30getConshdlrName(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getConshdlrName", 1); + + /* "src/pyscipopt/scip.pxi":970 + * def getConshdlrName(self): + * """Return the constraint handler's name""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * return constype + * + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_self->scip_cons))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":971 + * """Return the constraint handler's name""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + * return constype # <<<<<<<<<<<<<< + * + * def __hash__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_constype); + __pyx_r = __pyx_v_constype; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":968 + * return constype == 'nonlinear' + * + * def getConshdlrName(self): # <<<<<<<<<<<<<< + * """Return the constraint handler's name""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.getConshdlrName", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":973 + * return constype + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_cons) + * + */ + +/* Python wrapper */ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_10Constraint_33__hash__(PyObject *__pyx_v_self); /*proto*/ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_10Constraint_33__hash__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_32__hash__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_hash_t __pyx_pf_9pyscipopt_4scip_10Constraint_32__hash__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_hash_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__hash__", 1); + + /* "src/pyscipopt/scip.pxi":974 + * + * def __hash__(self): + * return hash(self.scip_cons) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 974, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":973 + * return constype + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self.scip_cons) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":976 + * return hash(self.scip_cons) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_cons == (other).scip_cons) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_35__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_35__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_34__eq__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_34__eq__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "src/pyscipopt/scip.pxi":977 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_cons == (other).scip_cons) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "src/pyscipopt/scip.pxi":978 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_cons == (other).scip_cons) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":977 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self.scip_cons == (other).scip_cons) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 977, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 977, __pyx_L1_error) + if (__pyx_t_5) { + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "src/pyscipopt/scip.pxi":978 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self.scip_cons == (other).scip_cons) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = (__pyx_v_self->scip_cons == ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_other)->scip_cons); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":976 + * return hash(self.scip_cons) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self.scip_cons == (other).scip_cons) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Constraint.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1940 + * cdef SCIP_CONS* scip_cons + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * + * @staticmethod + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Constraint_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Constraint_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Constraint_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_10Constraint_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_10Constraint_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_10Constraint_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_37__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_36__reduce_cython__, "Constraint.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_37__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_37__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_36__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_37__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_36__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_36__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_cons_cannot_be_convert, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Constraint.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_39__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_10Constraint_38__setstate_cython__, "Constraint.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_10Constraint_39__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_39__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_38__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_10Constraint_39__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Constraint.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_10Constraint_38__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_10Constraint_38__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_scip_cons_cannot_be_convert, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Constraint.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":981 + * + * + * cdef void relayMessage(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *msg) noexcept: # <<<<<<<<<<<<<< + * sys.stdout.write(msg.decode('UTF-8')) + * + */ + +static void __pyx_f_9pyscipopt_4scip_relayMessage(CYTHON_UNUSED SCIP_MESSAGEHDLR *__pyx_v_messagehdlr, CYTHON_UNUSED FILE *__pyx_v_file, char const *__pyx_v_msg) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("relayMessage", 1); + + /* "src/pyscipopt/scip.pxi":982 + * + * cdef void relayMessage(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *msg) noexcept: + * sys.stdout.write(msg.decode('UTF-8')) # <<<<<<<<<<<<<< + * + * cdef void relayErrorMessage(void *messagehdlr, FILE *file, const char *msg) noexcept: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 982, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_stdout); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 982, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_write); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 982, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_ssize_strlen(__pyx_v_msg); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 982, __pyx_L1_error) + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, __pyx_t_4, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 982, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 982, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":981 + * + * + * cdef void relayMessage(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *msg) noexcept: # <<<<<<<<<<<<<< + * sys.stdout.write(msg.decode('UTF-8')) + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pyscipopt.scip.relayMessage", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "src/pyscipopt/scip.pxi":984 + * sys.stdout.write(msg.decode('UTF-8')) + * + * cdef void relayErrorMessage(void *messagehdlr, FILE *file, const char *msg) noexcept: # <<<<<<<<<<<<<< + * sys.stderr.write(msg.decode('UTF-8')) + * + */ + +static void __pyx_f_9pyscipopt_4scip_relayErrorMessage(CYTHON_UNUSED void *__pyx_v_messagehdlr, CYTHON_UNUSED FILE *__pyx_v_file, char const *__pyx_v_msg) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("relayErrorMessage", 1); + + /* "src/pyscipopt/scip.pxi":985 + * + * cdef void relayErrorMessage(void *messagehdlr, FILE *file, const char *msg) noexcept: + * sys.stderr.write(msg.decode('UTF-8')) # <<<<<<<<<<<<<< + * + * # - remove create(), includeDefaultPlugins(), createProbBasic() methods + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_stderr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_write); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_4 = __Pyx_ssize_strlen(__pyx_v_msg); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 985, __pyx_L1_error) + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, __pyx_t_4, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":984 + * sys.stdout.write(msg.decode('UTF-8')) + * + * cdef void relayErrorMessage(void *messagehdlr, FILE *file, const char *msg) noexcept: # <<<<<<<<<<<<<< + * sys.stderr.write(msg.decode('UTF-8')) + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_WriteUnraisable("pyscipopt.scip.relayErrorMessage", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "src/pyscipopt/scip.pxi":996 + * """Main class holding a pointer to SCIP for managing most interactions""" + * + * def __init__(self, problemName='model', defaultPlugins=True, Model sourceModel=None, origcopy=False, globalcopy=True, enablepricing=False, createscip=True, threadsafe=False): # <<<<<<<<<<<<<< + * """ + * :param problemName: name of the problem (default 'model') + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Model_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model___init__, "\n :param problemName: name of the problem (default 'model')\n :param defaultPlugins: use default plugins? (default True)\n :param sourceModel: create a copy of the given Model instance (default None)\n :param origcopy: whether to call copy or copyOrig (default False)\n :param globalcopy: whether to create a global or a local copy (default True)\n :param enablepricing: whether to enable pricing in copy (default False)\n :param createscip: initialize the Model object and creates a SCIP instance\n :param threadsafe: False if data can be safely shared between the source and target problem\n "); +#if CYTHON_UPDATE_DESCRIPTOR_DOC +struct wrapperbase __pyx_wrapperbase_9pyscipopt_4scip_5Model___init__; +#endif +static int __pyx_pw_9pyscipopt_4scip_5Model_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_problemName = 0; + PyObject *__pyx_v_defaultPlugins = 0; + struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_sourceModel = 0; + PyObject *__pyx_v_origcopy = 0; + PyObject *__pyx_v_globalcopy = 0; + PyObject *__pyx_v_enablepricing = 0; + PyObject *__pyx_v_createscip = 0; + PyObject *__pyx_v_threadsafe = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[8] = {0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_problemName,&__pyx_n_s_defaultPlugins,&__pyx_n_s_sourceModel,&__pyx_n_s_origcopy,&__pyx_n_s_globalcopy,&__pyx_n_s_enablepricing,&__pyx_n_s_createscip,&__pyx_n_s_threadsafe,0}; + values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_n_u_model)); + values[1] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_True)); + values[2] = __Pyx_Arg_NewRef_VARARGS((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None)); + values[3] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_False)); + values[4] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_False)); + values[6] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_True)); + values[7] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 8: values[7] = __Pyx_Arg_VARARGS(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_VARARGS(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_VARARGS(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_problemName); + if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_defaultPlugins); + if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sourceModel); + if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_origcopy); + if (value) { values[3] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_globalcopy); + if (value) { values[4] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enablepricing); + if (value) { values[5] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_createscip); + if (value) { values[6] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_threadsafe); + if (value) { values[7] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 996, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 996, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 8: values[7] = __Pyx_Arg_VARARGS(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_VARARGS(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_VARARGS(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_VARARGS(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_VARARGS(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_problemName = values[0]; + __pyx_v_defaultPlugins = values[1]; + __pyx_v_sourceModel = ((struct __pyx_obj_9pyscipopt_4scip_Model *)values[2]); + __pyx_v_origcopy = values[3]; + __pyx_v_globalcopy = values[4]; + __pyx_v_enablepricing = values[5]; + __pyx_v_createscip = values[6]; + __pyx_v_threadsafe = values[7]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 8, __pyx_nargs); __PYX_ERR(0, 996, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sourceModel), __pyx_ptype_9pyscipopt_4scip_Model, 1, "sourceModel", 0))) __PYX_ERR(0, 996, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model___init__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_problemName, __pyx_v_defaultPlugins, __pyx_v_sourceModel, __pyx_v_origcopy, __pyx_v_globalcopy, __pyx_v_enablepricing, __pyx_v_createscip, __pyx_v_threadsafe); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Model___init__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_problemName, PyObject *__pyx_v_defaultPlugins, struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_sourceModel, PyObject *__pyx_v_origcopy, PyObject *__pyx_v_globalcopy, PyObject *__pyx_v_enablepricing, PyObject *__pyx_v_createscip, PyObject *__pyx_v_threadsafe) { + PyObject *__pyx_v_n = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + char const *__pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + char const *__pyx_t_16; + SCIP_Bool __pyx_t_17; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 1); + + /* "src/pyscipopt/scip.pxi":1007 + * :param threadsafe: False if data can be safely shared between the source and target problem + * """ + * if self.version() < MAJOR: # <<<<<<<<<<<<<< + * raise Exception("linked SCIP is not compatible to this version of PySCIPOpt - use at least version", MAJOR) + * if self.version() < MAJOR + MINOR/10.0 + PATCH/100.0: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_version); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MAJOR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1007, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 1007, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_5)) { + + /* "src/pyscipopt/scip.pxi":1008 + * """ + * if self.version() < MAJOR: + * raise Exception("linked SCIP is not compatible to this version of PySCIPOpt - use at least version", MAJOR) # <<<<<<<<<<<<<< + * if self.version() < MAJOR + MINOR/10.0 + PATCH/100.0: + * warnings.warn("linked SCIP {} is not recommended for this version of PySCIPOpt - use version {}.{}.{}".format(self.version(), MAJOR, MINOR, PATCH)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_MAJOR); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_kp_u_linked_SCIP_is_not_compatible_to); + __Pyx_GIVEREF(__pyx_kp_u_linked_SCIP_is_not_compatible_to); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_kp_u_linked_SCIP_is_not_compatible_to)) __PYX_ERR(0, 1008, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3)) __PYX_ERR(0, 1008, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1008, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1007 + * :param threadsafe: False if data can be safely shared between the source and target problem + * """ + * if self.version() < MAJOR: # <<<<<<<<<<<<<< + * raise Exception("linked SCIP is not compatible to this version of PySCIPOpt - use at least version", MAJOR) + * if self.version() < MAJOR + MINOR/10.0 + PATCH/100.0: + */ + } + + /* "src/pyscipopt/scip.pxi":1009 + * if self.version() < MAJOR: + * raise Exception("linked SCIP is not compatible to this version of PySCIPOpt - use at least version", MAJOR) + * if self.version() < MAJOR + MINOR/10.0 + PATCH/100.0: # <<<<<<<<<<<<<< + * warnings.warn("linked SCIP {} is not recommended for this version of PySCIPOpt - use version {}.{}.{}".format(self.version(), MAJOR, MINOR, PATCH)) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_version); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_MAJOR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_MINOR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyFloat_TrueDivideObjC(__pyx_t_1, __pyx_float_10_0, 10.0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_PATCH); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyFloat_TrueDivideObjC(__pyx_t_6, __pyx_float_100_0, 100.0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_6, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 1009, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":1010 + * raise Exception("linked SCIP is not compatible to this version of PySCIPOpt - use at least version", MAJOR) + * if self.version() < MAJOR + MINOR/10.0 + PATCH/100.0: + * warnings.warn("linked SCIP {} is not recommended for this version of PySCIPOpt - use version {}.{}.{}".format(self.version(), MAJOR, MINOR, PATCH)) # <<<<<<<<<<<<<< + * + * self._freescip = True + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_warnings); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_warn); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_linked_SCIP_is_not_recommended_f, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_version); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_MAJOR); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_MINOR); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GetModuleGlobalName(__pyx_t_10, __pyx_n_s_PATCH); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[5] = {__pyx_t_11, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 4+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1009 + * if self.version() < MAJOR: + * raise Exception("linked SCIP is not compatible to this version of PySCIPOpt - use at least version", MAJOR) + * if self.version() < MAJOR + MINOR/10.0 + PATCH/100.0: # <<<<<<<<<<<<<< + * warnings.warn("linked SCIP {} is not recommended for this version of PySCIPOpt - use version {}.{}.{}".format(self.version(), MAJOR, MINOR, PATCH)) + * + */ + } + + /* "src/pyscipopt/scip.pxi":1012 + * warnings.warn("linked SCIP {} is not recommended for this version of PySCIPOpt - use version {}.{}.{}".format(self.version(), MAJOR, MINOR, PATCH)) + * + * self._freescip = True # <<<<<<<<<<<<<< + * self._modelvars = {} + * + */ + __pyx_v_self->_freescip = 1; + + /* "src/pyscipopt/scip.pxi":1013 + * + * self._freescip = True + * self._modelvars = {} # <<<<<<<<<<<<<< + * + * if not createscip: + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1013, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->_modelvars); + __Pyx_DECREF(__pyx_v_self->_modelvars); + __pyx_v_self->_modelvars = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1015 + * self._modelvars = {} + * + * if not createscip: # <<<<<<<<<<<<<< + * # if no SCIP instance should be created, then an empty Model object is created. + * self._scip = NULL + */ + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_createscip); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 1015, __pyx_L1_error) + __pyx_t_12 = (!__pyx_t_5); + if (__pyx_t_12) { + + /* "src/pyscipopt/scip.pxi":1017 + * if not createscip: + * # if no SCIP instance should be created, then an empty Model object is created. + * self._scip = NULL # <<<<<<<<<<<<<< + * self._bestSol = None + * self._freescip = False + */ + __pyx_v_self->_scip = NULL; + + /* "src/pyscipopt/scip.pxi":1018 + * # if no SCIP instance should be created, then an empty Model object is created. + * self._scip = NULL + * self._bestSol = None # <<<<<<<<<<<<<< + * self._freescip = False + * elif sourceModel is None: + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->_bestSol); + __Pyx_DECREF((PyObject *)__pyx_v_self->_bestSol); + __pyx_v_self->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None); + + /* "src/pyscipopt/scip.pxi":1019 + * self._scip = NULL + * self._bestSol = None + * self._freescip = False # <<<<<<<<<<<<<< + * elif sourceModel is None: + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + */ + __pyx_v_self->_freescip = 0; + + /* "src/pyscipopt/scip.pxi":1015 + * self._modelvars = {} + * + * if not createscip: # <<<<<<<<<<<<<< + * # if no SCIP instance should be created, then an empty Model object is created. + * self._scip = NULL + */ + goto __pyx_L5; + } + + /* "src/pyscipopt/scip.pxi":1020 + * self._bestSol = None + * self._freescip = False + * elif sourceModel is None: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + * self._bestSol = None + */ + __pyx_t_12 = (((PyObject *)__pyx_v_sourceModel) == Py_None); + if (__pyx_t_12) { + + /* "src/pyscipopt/scip.pxi":1021 + * self._freescip = False + * elif sourceModel is None: + * PY_SCIP_CALL(SCIPcreate(&self._scip)) # <<<<<<<<<<<<<< + * self._bestSol = None + * if defaultPlugins: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreate((&__pyx_v_self->_scip))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1022 + * elif sourceModel is None: + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + * self._bestSol = None # <<<<<<<<<<<<<< + * if defaultPlugins: + * self.includeDefaultPlugins() + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->_bestSol); + __Pyx_DECREF((PyObject *)__pyx_v_self->_bestSol); + __pyx_v_self->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None); + + /* "src/pyscipopt/scip.pxi":1023 + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + * self._bestSol = None + * if defaultPlugins: # <<<<<<<<<<<<<< + * self.includeDefaultPlugins() + * self.createProbBasic(problemName) + */ + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_defaultPlugins); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 1023, __pyx_L1_error) + if (__pyx_t_12) { + + /* "src/pyscipopt/scip.pxi":1024 + * self._bestSol = None + * if defaultPlugins: + * self.includeDefaultPlugins() # <<<<<<<<<<<<<< + * self.createProbBasic(problemName) + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_includeDefaultPlugins); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1023 + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + * self._bestSol = None + * if defaultPlugins: # <<<<<<<<<<<<<< + * self.includeDefaultPlugins() + * self.createProbBasic(problemName) + */ + } + + /* "src/pyscipopt/scip.pxi":1025 + * if defaultPlugins: + * self.includeDefaultPlugins() + * self.createProbBasic(problemName) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createProbBasic); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_problemName}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1020 + * self._bestSol = None + * self._freescip = False + * elif sourceModel is None: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + * self._bestSol = None + */ + goto __pyx_L5; + } + + /* "src/pyscipopt/scip.pxi":1027 + * self.createProbBasic(problemName) + * else: + * PY_SCIP_CALL(SCIPcreate(&self._scip)) # <<<<<<<<<<<<<< + * self._bestSol = sourceModel._bestSol + * n = str_conversion(problemName) + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1027, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreate((&__pyx_v_self->_scip))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1027, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1027, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1028 + * else: + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + * self._bestSol = sourceModel._bestSol # <<<<<<<<<<<<<< + * n = str_conversion(problemName) + * if origcopy: + */ + __pyx_t_2 = ((PyObject *)__pyx_v_sourceModel->_bestSol); + __Pyx_INCREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF((PyObject *)__pyx_v_self->_bestSol); + __Pyx_DECREF((PyObject *)__pyx_v_self->_bestSol); + __pyx_v_self->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1029 + * PY_SCIP_CALL(SCIPcreate(&self._scip)) + * self._bestSol = sourceModel._bestSol + * n = str_conversion(problemName) # <<<<<<<<<<<<<< + * if origcopy: + * PY_SCIP_CALL(SCIPcopyOrig(sourceModel._scip, self._scip, NULL, NULL, n, enablepricing, threadsafe, True, self._valid)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1029, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_problemName}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1029, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1030 + * self._bestSol = sourceModel._bestSol + * n = str_conversion(problemName) + * if origcopy: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcopyOrig(sourceModel._scip, self._scip, NULL, NULL, n, enablepricing, threadsafe, True, self._valid)) + * else: + */ + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_origcopy); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 1030, __pyx_L1_error) + if (__pyx_t_12) { + + /* "src/pyscipopt/scip.pxi":1031 + * n = str_conversion(problemName) + * if origcopy: + * PY_SCIP_CALL(SCIPcopyOrig(sourceModel._scip, self._scip, NULL, NULL, n, enablepricing, threadsafe, True, self._valid)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPcopy(sourceModel._scip, self._scip, NULL, NULL, n, globalcopy, enablepricing, threadsafe, True, self._valid)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_13) && PyErr_Occurred())) __PYX_ERR(0, 1031, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_enablepricing); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1031, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_threadsafe); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1031, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcopyOrig(__pyx_v_sourceModel->_scip, __pyx_v_self->_scip, NULL, NULL, __pyx_t_13, __pyx_t_14, __pyx_t_15, 1, __pyx_v_self->_valid)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1030 + * self._bestSol = sourceModel._bestSol + * n = str_conversion(problemName) + * if origcopy: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcopyOrig(sourceModel._scip, self._scip, NULL, NULL, n, enablepricing, threadsafe, True, self._valid)) + * else: + */ + goto __pyx_L7; + } + + /* "src/pyscipopt/scip.pxi":1033 + * PY_SCIP_CALL(SCIPcopyOrig(sourceModel._scip, self._scip, NULL, NULL, n, enablepricing, threadsafe, True, self._valid)) + * else: + * PY_SCIP_CALL(SCIPcopy(sourceModel._scip, self._scip, NULL, NULL, n, globalcopy, enablepricing, threadsafe, True, self._valid)) # <<<<<<<<<<<<<< + * + * def __dealloc__(self): + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1033, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_16 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_16) && PyErr_Occurred())) __PYX_ERR(0, 1033, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_globalcopy); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1033, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_enablepricing); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1033, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_threadsafe); if (unlikely((__pyx_t_17 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1033, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcopy(__pyx_v_sourceModel->_scip, __pyx_v_self->_scip, NULL, NULL, __pyx_t_16, __pyx_t_15, __pyx_t_14, __pyx_t_17, 1, __pyx_v_self->_valid)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1033, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1033, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L7:; + } + __pyx_L5:; + + /* "src/pyscipopt/scip.pxi":996 + * """Main class holding a pointer to SCIP for managing most interactions""" + * + * def __init__(self, problemName='model', defaultPlugins=True, Model sourceModel=None, origcopy=False, globalcopy=True, enablepricing=False, createscip=True, threadsafe=False): # <<<<<<<<<<<<<< + * """ + * :param problemName: name of the problem (default 'model') + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("pyscipopt.scip.Model.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1035 + * PY_SCIP_CALL(SCIPcopy(sourceModel._scip, self._scip, NULL, NULL, n, globalcopy, enablepricing, threadsafe, True, self._valid)) + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # call C function directly, because we can no longer call this object's methods, according to + * # http://docs.cython.org/src/reference/extension_types.html#finalization-dealloc + */ + +/* Python wrapper */ +static void __pyx_pw_9pyscipopt_4scip_5Model_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_9pyscipopt_4scip_5Model_3__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_pf_9pyscipopt_4scip_5Model_2__dealloc__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_9pyscipopt_4scip_5Model_2__dealloc__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__dealloc__", 1); + + /* "src/pyscipopt/scip.pxi":1038 + * # call C function directly, because we can no longer call this object's methods, according to + * # http://docs.cython.org/src/reference/extension_types.html#finalization-dealloc + * if self._scip is not NULL and self._freescip and PY_SCIP_CALL: # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPfree(&self._scip) ) + * + */ + __pyx_t_2 = (__pyx_v_self->_scip != NULL); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->_freescip != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1038, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1039 + * # http://docs.cython.org/src/reference/extension_types.html#finalization-dealloc + * if self._scip is not NULL and self._freescip and PY_SCIP_CALL: + * PY_SCIP_CALL( SCIPfree(&self._scip) ) # <<<<<<<<<<<<<< + * + * def __hash__(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPfree((&__pyx_v_self->_scip))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1038 + * # call C function directly, because we can no longer call this object's methods, according to + * # http://docs.cython.org/src/reference/extension_types.html#finalization-dealloc + * if self._scip is not NULL and self._freescip and PY_SCIP_CALL: # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPfree(&self._scip) ) + * + */ + } + + /* "src/pyscipopt/scip.pxi":1035 + * PY_SCIP_CALL(SCIPcopy(sourceModel._scip, self._scip, NULL, NULL, n, globalcopy, enablepricing, threadsafe, True, self._valid)) + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # call C function directly, because we can no longer call this object's methods, according to + * # http://docs.cython.org/src/reference/extension_types.html#finalization-dealloc + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_WriteUnraisable("pyscipopt.scip.Model.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "src/pyscipopt/scip.pxi":1041 + * PY_SCIP_CALL( SCIPfree(&self._scip) ) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self._scip) + * + */ + +/* Python wrapper */ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_5Model_5__hash__(PyObject *__pyx_v_self); /*proto*/ +static Py_hash_t __pyx_pw_9pyscipopt_4scip_5Model_5__hash__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_4__hash__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_hash_t __pyx_pf_9pyscipopt_4scip_5Model_4__hash__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + Py_hash_t __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_hash_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__hash__", 1); + + /* "src/pyscipopt/scip.pxi":1042 + * + * def __hash__(self): + * return hash(self._scip) # <<<<<<<<<<<<<< + * + * def __eq__(self, other): + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(((size_t)__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1042, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_Hash(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_hash_t)-1))) __PYX_ERR(0, 1042, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1041 + * PY_SCIP_CALL( SCIPfree(&self._scip) ) + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return hash(self._scip) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.__hash__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + if (unlikely(__pyx_r == -1) && !PyErr_Occurred()) __pyx_r = -2; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1044 + * return hash(self._scip) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self._scip == (other)._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_7__eq__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_6__eq__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_6__eq__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_other) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__eq__", 1); + + /* "src/pyscipopt/scip.pxi":1045 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self._scip == (other)._scip) + * + */ + __Pyx_XDECREF(__pyx_r); + + /* "src/pyscipopt/scip.pxi":1046 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self._scip == (other)._scip) # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":1045 + * + * def __eq__(self, other): + * return (self.__class__ == other.__class__ # <<<<<<<<<<<<<< + * and self._scip == (other)._scip) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_other, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1045, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 1045, __pyx_L1_error) + if (__pyx_t_5) { + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L3_bool_binop_done; + } + + /* "src/pyscipopt/scip.pxi":1046 + * def __eq__(self, other): + * return (self.__class__ == other.__class__ + * and self._scip == (other)._scip) # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __pyx_t_5 = (__pyx_v_self->_scip == ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_other)->_scip); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1044 + * return hash(self._scip) + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return (self.__class__ == other.__class__ + * and self._scip == (other)._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.__eq__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1049 + * + * @staticmethod + * cdef create(SCIP* scip): # <<<<<<<<<<<<<< + * """Creates a model and appropriately assigns the scip and bestsol parameters + * """ + */ + +static PyObject *__pyx_f_9pyscipopt_4scip_5Model_create(SCIP *__pyx_v_scip) { + struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_model = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("create", 1); + + /* "src/pyscipopt/scip.pxi":1052 + * """Creates a model and appropriately assigns the scip and bestsol parameters + * """ + * if scip == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Model with SCIP* == NULL") + * model = Model(createscip=False) + */ + __pyx_t_1 = (__pyx_v_scip == NULL); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":1053 + * """ + * if scip == NULL: + * raise Warning("cannot create Model with SCIP* == NULL") # <<<<<<<<<<<<<< + * model = Model(createscip=False) + * model._scip = scip + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1053, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1053, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1052 + * """Creates a model and appropriately assigns the scip and bestsol parameters + * """ + * if scip == NULL: # <<<<<<<<<<<<<< + * raise Warning("cannot create Model with SCIP* == NULL") + * model = Model(createscip=False) + */ + } + + /* "src/pyscipopt/scip.pxi":1054 + * if scip == NULL: + * raise Warning("cannot create Model with SCIP* == NULL") + * model = Model(createscip=False) # <<<<<<<<<<<<<< + * model._scip = scip + * model._bestSol = Solution.create(scip, SCIPgetBestSol(scip)) + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_createscip, Py_False) < 0) __PYX_ERR(0, 1054, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model), __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1055 + * raise Warning("cannot create Model with SCIP* == NULL") + * model = Model(createscip=False) + * model._scip = scip # <<<<<<<<<<<<<< + * model._bestSol = Solution.create(scip, SCIPgetBestSol(scip)) + * return model + */ + __pyx_v_model->_scip = __pyx_v_scip; + + /* "src/pyscipopt/scip.pxi":1056 + * model = Model(createscip=False) + * model._scip = scip + * model._bestSol = Solution.create(scip, SCIPgetBestSol(scip)) # <<<<<<<<<<<<<< + * return model + * + */ + __pyx_t_3 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_scip, SCIPgetBestSol(__pyx_v_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_9pyscipopt_4scip_Solution))))) __PYX_ERR(0, 1056, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_model->_bestSol); + __Pyx_DECREF((PyObject *)__pyx_v_model->_bestSol); + __pyx_v_model->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1057 + * model._scip = scip + * model._bestSol = Solution.create(scip, SCIPgetBestSol(scip)) + * return model # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_model); + __pyx_r = ((PyObject *)__pyx_v_model); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1049 + * + * @staticmethod + * cdef create(SCIP* scip): # <<<<<<<<<<<<<< + * """Creates a model and appropriately assigns the scip and bestsol parameters + * """ + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.create", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_model); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1059 + * return model + * + * @property # <<<<<<<<<<<<<< + * def _freescip(self): + * """Return whether the underlying Scip pointer gets deallocted when the current + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_9_freescip_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_9_freescip_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_9_freescip___get__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_9_freescip___get__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 1); + + /* "src/pyscipopt/scip.pxi":1064 + * object is deleted. + * """ + * return self._freescip # <<<<<<<<<<<<<< + * + * @_freescip.setter + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_freescip); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1059 + * return model + * + * @property # <<<<<<<<<<<<<< + * def _freescip(self): + * """Return whether the underlying Scip pointer gets deallocted when the current + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model._freescip.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1066 + * return self._freescip + * + * @_freescip.setter # <<<<<<<<<<<<<< + * def _freescip(self, val): + * """Set whether the underlying Scip pointer gets deallocted when the current + */ + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Model_9_freescip_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Model_9_freescip_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_9_freescip_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), ((PyObject *)__pyx_v_val)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Model_9_freescip_2__set__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val) { + int __pyx_r; + SCIP_Bool __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "src/pyscipopt/scip.pxi":1071 + * object is deleted. + * """ + * self._freescip = val # <<<<<<<<<<<<<< + * + * @cython.always_allow_keywords(True) + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_val); if (unlikely((__pyx_t_1 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1071, __pyx_L1_error) + __pyx_v_self->_freescip = __pyx_t_1; + + /* "src/pyscipopt/scip.pxi":1066 + * return self._freescip + * + * @_freescip.setter # <<<<<<<<<<<<<< + * def _freescip(self, val): + * """Set whether the underlying Scip pointer gets deallocted when the current + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Model._freescip.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1073 + * self._freescip = val + * + * @cython.always_allow_keywords(True) # <<<<<<<<<<<<<< + * @staticmethod + * def from_ptr(capsule, take_ownership): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_9from_ptr(CYTHON_UNUSED PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_8from_ptr, "Model.from_ptr(capsule, take_ownership)\nCreate a Model from a given pointer.\n\n :param cpasule: The PyCapsule containing the SCIP pointer under the name \"scip\".\n :param take_ownership: Whether the newly created Model assumes ownership of the\n underlying Scip pointer (see `_freescip`).\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_9from_ptr = {"from_ptr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_9from_ptr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_8from_ptr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_9from_ptr(CYTHON_UNUSED PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_capsule = 0; + PyObject *__pyx_v_take_ownership = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("from_ptr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_capsule,&__pyx_n_s_take_ownership,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_capsule)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1073, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_take_ownership)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1073, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("from_ptr", 1, 2, 2, 1); __PYX_ERR(0, 1073, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "from_ptr") < 0)) __PYX_ERR(0, 1073, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_capsule = values[0]; + __pyx_v_take_ownership = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("from_ptr", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1073, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.from_ptr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_8from_ptr(__pyx_v_capsule, __pyx_v_take_ownership); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_8from_ptr(PyObject *__pyx_v_capsule, PyObject *__pyx_v_take_ownership) { + PyObject *__pyx_v_model = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + void *__pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("from_ptr", 1); + + /* "src/pyscipopt/scip.pxi":1082 + * underlying Scip pointer (see `_freescip`). + * """ + * if not PyCapsule_IsValid(capsule, "scip"): # <<<<<<<<<<<<<< + * raise ValueError("The given capsule does not contain a valid scip pointer") + * model = Model.create(PyCapsule_GetPointer(capsule, "scip")) + */ + __pyx_t_1 = (!PyCapsule_IsValid(__pyx_v_capsule, ((char const *)"scip"))); + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":1083 + * """ + * if not PyCapsule_IsValid(capsule, "scip"): + * raise ValueError("The given capsule does not contain a valid scip pointer") # <<<<<<<<<<<<<< + * model = Model.create(PyCapsule_GetPointer(capsule, "scip")) + * model._freescip = take_ownership + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1083, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1082 + * underlying Scip pointer (see `_freescip`). + * """ + * if not PyCapsule_IsValid(capsule, "scip"): # <<<<<<<<<<<<<< + * raise ValueError("The given capsule does not contain a valid scip pointer") + * model = Model.create(PyCapsule_GetPointer(capsule, "scip")) + */ + } + + /* "src/pyscipopt/scip.pxi":1084 + * if not PyCapsule_IsValid(capsule, "scip"): + * raise ValueError("The given capsule does not contain a valid scip pointer") + * model = Model.create(PyCapsule_GetPointer(capsule, "scip")) # <<<<<<<<<<<<<< + * model._freescip = take_ownership + * return model + */ + __pyx_t_3 = PyCapsule_GetPointer(__pyx_v_capsule, ((char const *)"scip")); if (unlikely(__pyx_t_3 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1084, __pyx_L1_error) + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_5Model_create(((SCIP *)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1084, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_model = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1085 + * raise ValueError("The given capsule does not contain a valid scip pointer") + * model = Model.create(PyCapsule_GetPointer(capsule, "scip")) + * model._freescip = take_ownership # <<<<<<<<<<<<<< + * return model + * + */ + if (__Pyx_PyObject_SetAttrStr(__pyx_v_model, __pyx_n_s_freescip, __pyx_v_take_ownership) < 0) __PYX_ERR(0, 1085, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1086 + * model = Model.create(PyCapsule_GetPointer(capsule, "scip")) + * model._freescip = take_ownership + * return model # <<<<<<<<<<<<<< + * + * @cython.always_allow_keywords(True) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_model); + __pyx_r = __pyx_v_model; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1073 + * self._freescip = val + * + * @cython.always_allow_keywords(True) # <<<<<<<<<<<<<< + * @staticmethod + * def from_ptr(capsule, take_ownership): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.from_ptr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_model); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1088 + * return model + * + * @cython.always_allow_keywords(True) # <<<<<<<<<<<<<< + * def to_ptr(self, give_ownership): + * """Return the underlying Scip pointer to the current Model. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_11to_ptr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_10to_ptr, "Model.to_ptr(self, give_ownership)\nReturn the underlying Scip pointer to the current Model.\n\n :param give_ownership: Whether the current Model gives away ownership of the\n underlying Scip pointer (see `_freescip`).\n :return capsule: The underlying pointer to the current Model, wrapped in a\n PyCapsule under the name \"scip\".\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_11to_ptr = {"to_ptr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_11to_ptr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_10to_ptr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_11to_ptr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_give_ownership = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("to_ptr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_give_ownership,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_give_ownership)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1088, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "to_ptr") < 0)) __PYX_ERR(0, 1088, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_give_ownership = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("to_ptr", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1088, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.to_ptr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_10to_ptr(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_give_ownership); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_10to_ptr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_give_ownership) { + PyObject *__pyx_v_capsule = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("to_ptr", 1); + + /* "src/pyscipopt/scip.pxi":1097 + * PyCapsule under the name "scip". + * """ + * capsule = PyCapsule_New(self._scip, "scip", NULL) # <<<<<<<<<<<<<< + * if give_ownership: + * self._freescip = False + */ + __pyx_t_1 = PyCapsule_New(((void *)__pyx_v_self->_scip), ((char const *)"scip"), NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_capsule = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1098 + * """ + * capsule = PyCapsule_New(self._scip, "scip", NULL) + * if give_ownership: # <<<<<<<<<<<<<< + * self._freescip = False + * return capsule + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_give_ownership); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1098, __pyx_L1_error) + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1099 + * capsule = PyCapsule_New(self._scip, "scip", NULL) + * if give_ownership: + * self._freescip = False # <<<<<<<<<<<<<< + * return capsule + * + */ + __pyx_v_self->_freescip = 0; + + /* "src/pyscipopt/scip.pxi":1098 + * """ + * capsule = PyCapsule_New(self._scip, "scip", NULL) + * if give_ownership: # <<<<<<<<<<<<<< + * self._freescip = False + * return capsule + */ + } + + /* "src/pyscipopt/scip.pxi":1100 + * if give_ownership: + * self._freescip = False + * return capsule # <<<<<<<<<<<<<< + * + * def includeDefaultPlugins(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_capsule); + __pyx_r = __pyx_v_capsule; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1088 + * return model + * + * @cython.always_allow_keywords(True) # <<<<<<<<<<<<<< + * def to_ptr(self, give_ownership): + * """Return the underlying Scip pointer to the current Model. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.to_ptr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_capsule); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1102 + * return capsule + * + * def includeDefaultPlugins(self): # <<<<<<<<<<<<<< + * """Includes all default plug-ins into SCIP""" + * PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_13includeDefaultPlugins(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_12includeDefaultPlugins, "Model.includeDefaultPlugins(self)\nIncludes all default plug-ins into SCIP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_13includeDefaultPlugins = {"includeDefaultPlugins", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_13includeDefaultPlugins, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_12includeDefaultPlugins}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_13includeDefaultPlugins(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeDefaultPlugins (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("includeDefaultPlugins", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "includeDefaultPlugins", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_12includeDefaultPlugins(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_12includeDefaultPlugins(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeDefaultPlugins", 1); + + /* "src/pyscipopt/scip.pxi":1104 + * def includeDefaultPlugins(self): + * """Includes all default plug-ins into SCIP""" + * PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip)) # <<<<<<<<<<<<<< + * + * def createProbBasic(self, problemName='model'): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeDefaultPlugins(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1102 + * return capsule + * + * def includeDefaultPlugins(self): # <<<<<<<<<<<<<< + * """Includes all default plug-ins into SCIP""" + * PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeDefaultPlugins", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1106 + * PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip)) + * + * def createProbBasic(self, problemName='model'): # <<<<<<<<<<<<<< + * """Create new problem instance with given name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_15createProbBasic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_14createProbBasic, "Model.createProbBasic(self, problemName=u'model')\nCreate new problem instance with given name\n\n :param problemName: name of model or problem (Default value = 'model')\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_15createProbBasic = {"createProbBasic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_15createProbBasic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_14createProbBasic}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_15createProbBasic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_problemName = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createProbBasic (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_problemName,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_model)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_problemName); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1106, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createProbBasic") < 0)) __PYX_ERR(0, 1106, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_problemName = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createProbBasic", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1106, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createProbBasic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_14createProbBasic(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_problemName); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_14createProbBasic(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_problemName) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createProbBasic", 1); + + /* "src/pyscipopt/scip.pxi":1112 + * + * """ + * n = str_conversion(problemName) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateProbBasic(self._scip, n)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_problemName}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1113 + * """ + * n = str_conversion(problemName) + * PY_SCIP_CALL(SCIPcreateProbBasic(self._scip, n)) # <<<<<<<<<<<<<< + * + * def freeProb(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 1113, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateProbBasic(__pyx_v_self->_scip, __pyx_t_5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1106 + * PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip)) + * + * def createProbBasic(self, problemName='model'): # <<<<<<<<<<<<<< + * """Create new problem instance with given name + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.createProbBasic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1115 + * PY_SCIP_CALL(SCIPcreateProbBasic(self._scip, n)) + * + * def freeProb(self): # <<<<<<<<<<<<<< + * """Frees problem and solution process data""" + * PY_SCIP_CALL(SCIPfreeProb(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_17freeProb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_16freeProb, "Model.freeProb(self)\nFrees problem and solution process data"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_17freeProb = {"freeProb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_17freeProb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_16freeProb}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_17freeProb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("freeProb (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("freeProb", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "freeProb", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_16freeProb(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_16freeProb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("freeProb", 1); + + /* "src/pyscipopt/scip.pxi":1117 + * def freeProb(self): + * """Frees problem and solution process data""" + * PY_SCIP_CALL(SCIPfreeProb(self._scip)) # <<<<<<<<<<<<<< + * + * def freeTransform(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPfreeProb(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1115 + * PY_SCIP_CALL(SCIPcreateProbBasic(self._scip, n)) + * + * def freeProb(self): # <<<<<<<<<<<<<< + * """Frees problem and solution process data""" + * PY_SCIP_CALL(SCIPfreeProb(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.freeProb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1119 + * PY_SCIP_CALL(SCIPfreeProb(self._scip)) + * + * def freeTransform(self): # <<<<<<<<<<<<<< + * """Frees all solution process data including presolving and transformed problem, only original problem is kept""" + * self._modelvars = { + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_19freeTransform(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_18freeTransform, "Model.freeTransform(self)\nFrees all solution process data including presolving and transformed problem, only original problem is kept"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_19freeTransform = {"freeTransform", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_19freeTransform, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_18freeTransform}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_19freeTransform(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("freeTransform (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("freeTransform", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "freeTransform", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_18freeTransform(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_18freeTransform(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_9genexpr26__pyx_v_var = NULL; + PyObject *__pyx_9genexpr26__pyx_v_value = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("freeTransform", 1); + + /* "src/pyscipopt/scip.pxi":1121 + * def freeTransform(self): + * """Frees all solution process data including presolving and transformed problem, only original problem is kept""" + * self._modelvars = { # <<<<<<<<<<<<<< + * var: value + * for var, value in self._modelvars.items() + */ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1121, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "src/pyscipopt/scip.pxi":1123 + * self._modelvars = { + * var: value + * for var, value in self._modelvars.items() # <<<<<<<<<<<<<< + * if value.isOriginal() + * } + */ + __pyx_t_3 = 0; + if (unlikely(__pyx_v_self->_modelvars == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 1123, __pyx_L5_error) + } + __pyx_t_6 = __Pyx_dict_iterator(__pyx_v_self->_modelvars, 0, __pyx_n_s_items, (&__pyx_t_4), (&__pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1123, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_6; + __pyx_t_6 = 0; + while (1) { + __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_4, &__pyx_t_3, &__pyx_t_6, &__pyx_t_7, NULL, __pyx_t_5); + if (unlikely(__pyx_t_8 == 0)) break; + if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 1123, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_9genexpr26__pyx_v_var, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_9genexpr26__pyx_v_value, __pyx_t_7); + __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":1124 + * var: value + * for var, value in self._modelvars.items() + * if value.isOriginal() # <<<<<<<<<<<<<< + * } + * PY_SCIP_CALL(SCIPfreeTransform(self._scip)) + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr26__pyx_v_value, __pyx_n_s_isOriginal); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1124, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, NULL}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 0+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1124, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_10 < 0))) __PYX_ERR(0, 1124, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_10) { + + /* "src/pyscipopt/scip.pxi":1122 + * """Frees all solution process data including presolving and transformed problem, only original problem is kept""" + * self._modelvars = { + * var: value # <<<<<<<<<<<<<< + * for var, value in self._modelvars.items() + * if value.isOriginal() + */ + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_9genexpr26__pyx_v_var, (PyObject*)__pyx_9genexpr26__pyx_v_value))) __PYX_ERR(0, 1122, __pyx_L5_error) + + /* "src/pyscipopt/scip.pxi":1124 + * var: value + * for var, value in self._modelvars.items() + * if value.isOriginal() # <<<<<<<<<<<<<< + * } + * PY_SCIP_CALL(SCIPfreeTransform(self._scip)) + */ + } + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_value); __pyx_9genexpr26__pyx_v_value = 0; + __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_var); __pyx_9genexpr26__pyx_v_var = 0; + goto __pyx_L9_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_value); __pyx_9genexpr26__pyx_v_value = 0; + __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_var); __pyx_9genexpr26__pyx_v_var = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + + /* "src/pyscipopt/scip.pxi":1121 + * def freeTransform(self): + * """Frees all solution process data including presolving and transformed problem, only original problem is kept""" + * self._modelvars = { # <<<<<<<<<<<<<< + * var: value + * for var, value in self._modelvars.items() + */ + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_modelvars); + __Pyx_DECREF(__pyx_v_self->_modelvars); + __pyx_v_self->_modelvars = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1126 + * if value.isOriginal() + * } + * PY_SCIP_CALL(SCIPfreeTransform(self._scip)) # <<<<<<<<<<<<<< + * + * def version(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPfreeTransform(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1119 + * PY_SCIP_CALL(SCIPfreeProb(self._scip)) + * + * def freeTransform(self): # <<<<<<<<<<<<<< + * """Frees all solution process data including presolving and transformed problem, only original problem is kept""" + * self._modelvars = { + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.freeTransform", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_var); + __Pyx_XDECREF(__pyx_9genexpr26__pyx_v_value); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1128 + * PY_SCIP_CALL(SCIPfreeTransform(self._scip)) + * + * def version(self): # <<<<<<<<<<<<<< + * """Retrieve SCIP version""" + * return SCIPversion() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_21version(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_20version, "Model.version(self)\nRetrieve SCIP version"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_21version = {"version", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_21version, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_20version}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_21version(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("version (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("version", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "version", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_20version(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_20version(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("version", 1); + + /* "src/pyscipopt/scip.pxi":1130 + * def version(self): + * """Retrieve SCIP version""" + * return SCIPversion() # <<<<<<<<<<<<<< + * + * def printVersion(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPversion()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1128 + * PY_SCIP_CALL(SCIPfreeTransform(self._scip)) + * + * def version(self): # <<<<<<<<<<<<<< + * """Retrieve SCIP version""" + * return SCIPversion() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.version", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1132 + * return SCIPversion() + * + * def printVersion(self): # <<<<<<<<<<<<<< + * """Print version, copyright information and compile mode""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_23printVersion(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_22printVersion, "Model.printVersion(self)\nPrint version, copyright information and compile mode"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_23printVersion = {"printVersion", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_23printVersion, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_22printVersion}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_23printVersion(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("printVersion (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("printVersion", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "printVersion", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_22printVersion(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_22printVersion(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("printVersion", 1); + + /* "src/pyscipopt/scip.pxi":1134 + * def printVersion(self): + * """Print version, copyright information and compile mode""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 1134, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1135 + * """Print version, copyright information and compile mode""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * SCIPprintVersion(self._scip, NULL) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1137 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * SCIPprintVersion(self._scip, NULL) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + SCIPprintVersion(__pyx_v_self->_scip, NULL); + + /* "src/pyscipopt/scip.pxi":1139 + * SCIPprintVersion(self._scip, NULL) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def printExternalCodeVersions(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1132 + * return SCIPversion() + * + * def printVersion(self): # <<<<<<<<<<<<<< + * """Print version, copyright information and compile mode""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.printVersion", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1141 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def printExternalCodeVersions(self): # <<<<<<<<<<<<<< + * """Print external code versions, e.g. symmetry, non-linear solver, lp solver""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_25printExternalCodeVersions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_24printExternalCodeVersions, "Model.printExternalCodeVersions(self)\nPrint external code versions, e.g. symmetry, non-linear solver, lp solver"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_25printExternalCodeVersions = {"printExternalCodeVersions", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_25printExternalCodeVersions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_24printExternalCodeVersions}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_25printExternalCodeVersions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("printExternalCodeVersions (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("printExternalCodeVersions", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "printExternalCodeVersions", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_24printExternalCodeVersions(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_24printExternalCodeVersions(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("printExternalCodeVersions", 1); + + /* "src/pyscipopt/scip.pxi":1143 + * def printExternalCodeVersions(self): + * """Print external code versions, e.g. symmetry, non-linear solver, lp solver""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 1143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1144 + * """Print external code versions, e.g. symmetry, non-linear solver, lp solver""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * SCIPprintExternalCodes(self._scip, NULL) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1146 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * SCIPprintExternalCodes(self._scip, NULL) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + SCIPprintExternalCodes(__pyx_v_self->_scip, NULL); + + /* "src/pyscipopt/scip.pxi":1148 + * SCIPprintExternalCodes(self._scip, NULL) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def getProbName(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1141 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def printExternalCodeVersions(self): # <<<<<<<<<<<<<< + * """Print external code versions, e.g. symmetry, non-linear solver, lp solver""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.printExternalCodeVersions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1150 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getProbName(self): # <<<<<<<<<<<<<< + * """Retrieve problem name""" + * return bytes(SCIPgetProbName(self._scip)).decode('UTF-8') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_27getProbName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_26getProbName, "Model.getProbName(self)\nRetrieve problem name"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_27getProbName = {"getProbName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_27getProbName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_26getProbName}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_27getProbName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getProbName (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getProbName", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getProbName", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_26getProbName(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_26getProbName(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getProbName", 1); + + /* "src/pyscipopt/scip.pxi":1152 + * def getProbName(self): + * """Retrieve problem name""" + * return bytes(SCIPgetProbName(self._scip)).decode('UTF-8') # <<<<<<<<<<<<<< + * + * def getTotalTime(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPgetProbName(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1150 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getProbName(self): # <<<<<<<<<<<<<< + * """Retrieve problem name""" + * return bytes(SCIPgetProbName(self._scip)).decode('UTF-8') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getProbName", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1154 + * return bytes(SCIPgetProbName(self._scip)).decode('UTF-8') + * + * def getTotalTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current total SCIP time in seconds, i.e. the total time since the SCIP instance has been created""" + * return SCIPgetTotalTime(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_29getTotalTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_28getTotalTime, "Model.getTotalTime(self)\nRetrieve the current total SCIP time in seconds, i.e. the total time since the SCIP instance has been created"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_29getTotalTime = {"getTotalTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_29getTotalTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_28getTotalTime}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_29getTotalTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getTotalTime (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getTotalTime", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTotalTime", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_28getTotalTime(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_28getTotalTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getTotalTime", 1); + + /* "src/pyscipopt/scip.pxi":1156 + * def getTotalTime(self): + * """Retrieve the current total SCIP time in seconds, i.e. the total time since the SCIP instance has been created""" + * return SCIPgetTotalTime(self._scip) # <<<<<<<<<<<<<< + * + * def getSolvingTime(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetTotalTime(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1154 + * return bytes(SCIPgetProbName(self._scip)).decode('UTF-8') + * + * def getTotalTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current total SCIP time in seconds, i.e. the total time since the SCIP instance has been created""" + * return SCIPgetTotalTime(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getTotalTime", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1158 + * return SCIPgetTotalTime(self._scip) + * + * def getSolvingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current solving time in seconds""" + * return SCIPgetSolvingTime(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_31getSolvingTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_30getSolvingTime, "Model.getSolvingTime(self)\nRetrieve the current solving time in seconds"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_31getSolvingTime = {"getSolvingTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_31getSolvingTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_30getSolvingTime}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_31getSolvingTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getSolvingTime (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getSolvingTime", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSolvingTime", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_30getSolvingTime(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_30getSolvingTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getSolvingTime", 1); + + /* "src/pyscipopt/scip.pxi":1160 + * def getSolvingTime(self): + * """Retrieve the current solving time in seconds""" + * return SCIPgetSolvingTime(self._scip) # <<<<<<<<<<<<<< + * + * def getReadingTime(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetSolvingTime(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1158 + * return SCIPgetTotalTime(self._scip) + * + * def getSolvingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current solving time in seconds""" + * return SCIPgetSolvingTime(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getSolvingTime", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1162 + * return SCIPgetSolvingTime(self._scip) + * + * def getReadingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current reading time in seconds""" + * return SCIPgetReadingTime(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_33getReadingTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_32getReadingTime, "Model.getReadingTime(self)\nRetrieve the current reading time in seconds"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_33getReadingTime = {"getReadingTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_33getReadingTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_32getReadingTime}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_33getReadingTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getReadingTime (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getReadingTime", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getReadingTime", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_32getReadingTime(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_32getReadingTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getReadingTime", 1); + + /* "src/pyscipopt/scip.pxi":1164 + * def getReadingTime(self): + * """Retrieve the current reading time in seconds""" + * return SCIPgetReadingTime(self._scip) # <<<<<<<<<<<<<< + * + * def getPresolvingTime(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetReadingTime(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1162 + * return SCIPgetSolvingTime(self._scip) + * + * def getReadingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current reading time in seconds""" + * return SCIPgetReadingTime(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getReadingTime", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1166 + * return SCIPgetReadingTime(self._scip) + * + * def getPresolvingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the curernt presolving time in seconds""" + * return SCIPgetPresolvingTime(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_35getPresolvingTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_34getPresolvingTime, "Model.getPresolvingTime(self)\nRetrieve the curernt presolving time in seconds"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_35getPresolvingTime = {"getPresolvingTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_35getPresolvingTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_34getPresolvingTime}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_35getPresolvingTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPresolvingTime (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getPresolvingTime", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPresolvingTime", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_34getPresolvingTime(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_34getPresolvingTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getPresolvingTime", 1); + + /* "src/pyscipopt/scip.pxi":1168 + * def getPresolvingTime(self): + * """Retrieve the curernt presolving time in seconds""" + * return SCIPgetPresolvingTime(self._scip) # <<<<<<<<<<<<<< + * + * def getNLPIterations(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetPresolvingTime(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1166 + * return SCIPgetReadingTime(self._scip) + * + * def getPresolvingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the curernt presolving time in seconds""" + * return SCIPgetPresolvingTime(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getPresolvingTime", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1170 + * return SCIPgetPresolvingTime(self._scip) + * + * def getNLPIterations(self): # <<<<<<<<<<<<<< + * """Retrieve the total number of LP iterations so far.""" + * return SCIPgetNLPIterations(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_37getNLPIterations(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_36getNLPIterations, "Model.getNLPIterations(self)\nRetrieve the total number of LP iterations so far."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_37getNLPIterations = {"getNLPIterations", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_37getNLPIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_36getNLPIterations}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_37getNLPIterations(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNLPIterations (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNLPIterations", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLPIterations", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_36getNLPIterations(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_36getNLPIterations(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNLPIterations", 1); + + /* "src/pyscipopt/scip.pxi":1172 + * def getNLPIterations(self): + * """Retrieve the total number of LP iterations so far.""" + * return SCIPgetNLPIterations(self._scip) # <<<<<<<<<<<<<< + * + * def getNNodes(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNLPIterations(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1170 + * return SCIPgetPresolvingTime(self._scip) + * + * def getNLPIterations(self): # <<<<<<<<<<<<<< + * """Retrieve the total number of LP iterations so far.""" + * return SCIPgetNLPIterations(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNLPIterations", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1174 + * return SCIPgetNLPIterations(self._scip) + * + * def getNNodes(self): # <<<<<<<<<<<<<< + * """gets number of processed nodes in current run, including the focus node.""" + * return SCIPgetNNodes(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_39getNNodes(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_38getNNodes, "Model.getNNodes(self)\ngets number of processed nodes in current run, including the focus node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_39getNNodes = {"getNNodes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_39getNNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_38getNNodes}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_39getNNodes(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNNodes (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNNodes", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNNodes", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_38getNNodes(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_38getNNodes(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNNodes", 1); + + /* "src/pyscipopt/scip.pxi":1176 + * def getNNodes(self): + * """gets number of processed nodes in current run, including the focus node.""" + * return SCIPgetNNodes(self._scip) # <<<<<<<<<<<<<< + * + * def getNTotalNodes(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNNodes(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1174 + * return SCIPgetNLPIterations(self._scip) + * + * def getNNodes(self): # <<<<<<<<<<<<<< + * """gets number of processed nodes in current run, including the focus node.""" + * return SCIPgetNNodes(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNNodes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1178 + * return SCIPgetNNodes(self._scip) + * + * def getNTotalNodes(self): # <<<<<<<<<<<<<< + * """gets number of processed nodes in all runs, including the focus node.""" + * return SCIPgetNTotalNodes(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_41getNTotalNodes(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_40getNTotalNodes, "Model.getNTotalNodes(self)\ngets number of processed nodes in all runs, including the focus node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_41getNTotalNodes = {"getNTotalNodes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_41getNTotalNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_40getNTotalNodes}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_41getNTotalNodes(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNTotalNodes (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNTotalNodes", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNTotalNodes", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_40getNTotalNodes(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_40getNTotalNodes(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNTotalNodes", 1); + + /* "src/pyscipopt/scip.pxi":1180 + * def getNTotalNodes(self): + * """gets number of processed nodes in all runs, including the focus node.""" + * return SCIPgetNTotalNodes(self._scip) # <<<<<<<<<<<<<< + * + * def getNFeasibleLeaves(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNTotalNodes(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1178 + * return SCIPgetNNodes(self._scip) + * + * def getNTotalNodes(self): # <<<<<<<<<<<<<< + * """gets number of processed nodes in all runs, including the focus node.""" + * return SCIPgetNTotalNodes(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNTotalNodes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1182 + * return SCIPgetNTotalNodes(self._scip) + * + * def getNFeasibleLeaves(self): # <<<<<<<<<<<<<< + * """Retrieve number of leaf nodes processed with feasible relaxation solution.""" + * return SCIPgetNFeasibleLeaves(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_43getNFeasibleLeaves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_42getNFeasibleLeaves, "Model.getNFeasibleLeaves(self)\nRetrieve number of leaf nodes processed with feasible relaxation solution."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_43getNFeasibleLeaves = {"getNFeasibleLeaves", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_43getNFeasibleLeaves, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_42getNFeasibleLeaves}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_43getNFeasibleLeaves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNFeasibleLeaves (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNFeasibleLeaves", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNFeasibleLeaves", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_42getNFeasibleLeaves(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_42getNFeasibleLeaves(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNFeasibleLeaves", 1); + + /* "src/pyscipopt/scip.pxi":1184 + * def getNFeasibleLeaves(self): + * """Retrieve number of leaf nodes processed with feasible relaxation solution.""" + * return SCIPgetNFeasibleLeaves(self._scip) # <<<<<<<<<<<<<< + * + * def getNInfeasibleLeaves(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNFeasibleLeaves(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1182 + * return SCIPgetNTotalNodes(self._scip) + * + * def getNFeasibleLeaves(self): # <<<<<<<<<<<<<< + * """Retrieve number of leaf nodes processed with feasible relaxation solution.""" + * return SCIPgetNFeasibleLeaves(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNFeasibleLeaves", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1186 + * return SCIPgetNFeasibleLeaves(self._scip) + * + * def getNInfeasibleLeaves(self): # <<<<<<<<<<<<<< + * """gets number of infeasible leaf nodes processed.""" + * return SCIPgetNInfeasibleLeaves(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_45getNInfeasibleLeaves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_44getNInfeasibleLeaves, "Model.getNInfeasibleLeaves(self)\ngets number of infeasible leaf nodes processed."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_45getNInfeasibleLeaves = {"getNInfeasibleLeaves", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_45getNInfeasibleLeaves, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_44getNInfeasibleLeaves}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_45getNInfeasibleLeaves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNInfeasibleLeaves (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNInfeasibleLeaves", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNInfeasibleLeaves", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_44getNInfeasibleLeaves(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_44getNInfeasibleLeaves(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNInfeasibleLeaves", 1); + + /* "src/pyscipopt/scip.pxi":1188 + * def getNInfeasibleLeaves(self): + * """gets number of infeasible leaf nodes processed.""" + * return SCIPgetNInfeasibleLeaves(self._scip) # <<<<<<<<<<<<<< + * + * def getNLeaves(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNInfeasibleLeaves(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1186 + * return SCIPgetNFeasibleLeaves(self._scip) + * + * def getNInfeasibleLeaves(self): # <<<<<<<<<<<<<< + * """gets number of infeasible leaf nodes processed.""" + * return SCIPgetNInfeasibleLeaves(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNInfeasibleLeaves", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1190 + * return SCIPgetNInfeasibleLeaves(self._scip) + * + * def getNLeaves(self): # <<<<<<<<<<<<<< + * """gets number of leaves in the tree.""" + * return SCIPgetNLeaves(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_47getNLeaves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_46getNLeaves, "Model.getNLeaves(self)\ngets number of leaves in the tree."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_47getNLeaves = {"getNLeaves", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_47getNLeaves, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_46getNLeaves}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_47getNLeaves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNLeaves (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNLeaves", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLeaves", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_46getNLeaves(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_46getNLeaves(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNLeaves", 1); + + /* "src/pyscipopt/scip.pxi":1192 + * def getNLeaves(self): + * """gets number of leaves in the tree.""" + * return SCIPgetNLeaves(self._scip) # <<<<<<<<<<<<<< + * + * def getNChildren(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNLeaves(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1190 + * return SCIPgetNInfeasibleLeaves(self._scip) + * + * def getNLeaves(self): # <<<<<<<<<<<<<< + * """gets number of leaves in the tree.""" + * return SCIPgetNLeaves(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNLeaves", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1194 + * return SCIPgetNLeaves(self._scip) + * + * def getNChildren(self): # <<<<<<<<<<<<<< + * """gets number of children of focus node.""" + * return SCIPgetNChildren(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_49getNChildren(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_48getNChildren, "Model.getNChildren(self)\ngets number of children of focus node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_49getNChildren = {"getNChildren", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_49getNChildren, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_48getNChildren}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_49getNChildren(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNChildren (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNChildren", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNChildren", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_48getNChildren(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_48getNChildren(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNChildren", 1); + + /* "src/pyscipopt/scip.pxi":1196 + * def getNChildren(self): + * """gets number of children of focus node.""" + * return SCIPgetNChildren(self._scip) # <<<<<<<<<<<<<< + * + * def getNSiblings(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNChildren(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1194 + * return SCIPgetNLeaves(self._scip) + * + * def getNChildren(self): # <<<<<<<<<<<<<< + * """gets number of children of focus node.""" + * return SCIPgetNChildren(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNChildren", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1198 + * return SCIPgetNChildren(self._scip) + * + * def getNSiblings(self): # <<<<<<<<<<<<<< + * """gets number of siblings of focus node.""" + * return SCIPgetNSiblings(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_51getNSiblings(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_50getNSiblings, "Model.getNSiblings(self)\ngets number of siblings of focus node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_51getNSiblings = {"getNSiblings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_51getNSiblings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_50getNSiblings}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_51getNSiblings(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNSiblings (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNSiblings", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNSiblings", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_50getNSiblings(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_50getNSiblings(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNSiblings", 1); + + /* "src/pyscipopt/scip.pxi":1200 + * def getNSiblings(self): + * """gets number of siblings of focus node.""" + * return SCIPgetNSiblings(self._scip) # <<<<<<<<<<<<<< + * + * def getCurrentNode(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNSiblings(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1198 + * return SCIPgetNChildren(self._scip) + * + * def getNSiblings(self): # <<<<<<<<<<<<<< + * """gets number of siblings of focus node.""" + * return SCIPgetNSiblings(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNSiblings", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1202 + * return SCIPgetNSiblings(self._scip) + * + * def getCurrentNode(self): # <<<<<<<<<<<<<< + * """Retrieve current node.""" + * return Node.create(SCIPgetCurrentNode(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_53getCurrentNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_52getCurrentNode, "Model.getCurrentNode(self)\nRetrieve current node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_53getCurrentNode = {"getCurrentNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_53getCurrentNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_52getCurrentNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_53getCurrentNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getCurrentNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getCurrentNode", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getCurrentNode", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_52getCurrentNode(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_52getCurrentNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getCurrentNode", 1); + + /* "src/pyscipopt/scip.pxi":1204 + * def getCurrentNode(self): + * """Retrieve current node.""" + * return Node.create(SCIPgetCurrentNode(self._scip)) # <<<<<<<<<<<<<< + * + * def getGap(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(SCIPgetCurrentNode(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1202 + * return SCIPgetNSiblings(self._scip) + * + * def getCurrentNode(self): # <<<<<<<<<<<<<< + * """Retrieve current node.""" + * return Node.create(SCIPgetCurrentNode(self._scip)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getCurrentNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1206 + * return Node.create(SCIPgetCurrentNode(self._scip)) + * + * def getGap(self): # <<<<<<<<<<<<<< + * """Retrieve the gap, i.e. |(primalbound - dualbound)/min(|primalbound|,|dualbound|)|.""" + * return SCIPgetGap(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_55getGap(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_54getGap, "Model.getGap(self)\nRetrieve the gap, i.e. |(primalbound - dualbound)/min(|primalbound|,|dualbound|)|."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_55getGap = {"getGap", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_55getGap, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_54getGap}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_55getGap(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getGap (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getGap", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getGap", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_54getGap(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_54getGap(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getGap", 1); + + /* "src/pyscipopt/scip.pxi":1208 + * def getGap(self): + * """Retrieve the gap, i.e. |(primalbound - dualbound)/min(|primalbound|,|dualbound|)|.""" + * return SCIPgetGap(self._scip) # <<<<<<<<<<<<<< + * + * def getDepth(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetGap(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1206 + * return Node.create(SCIPgetCurrentNode(self._scip)) + * + * def getGap(self): # <<<<<<<<<<<<<< + * """Retrieve the gap, i.e. |(primalbound - dualbound)/min(|primalbound|,|dualbound|)|.""" + * return SCIPgetGap(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getGap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1210 + * return SCIPgetGap(self._scip) + * + * def getDepth(self): # <<<<<<<<<<<<<< + * """Retrieve the depth of the current node""" + * return SCIPgetDepth(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_57getDepth(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_56getDepth, "Model.getDepth(self)\nRetrieve the depth of the current node"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_57getDepth = {"getDepth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_57getDepth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_56getDepth}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_57getDepth(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDepth (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getDepth", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDepth", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_56getDepth(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_56getDepth(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDepth", 1); + + /* "src/pyscipopt/scip.pxi":1212 + * def getDepth(self): + * """Retrieve the depth of the current node""" + * return SCIPgetDepth(self._scip) # <<<<<<<<<<<<<< + * + * def infinity(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetDepth(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1210 + * return SCIPgetGap(self._scip) + * + * def getDepth(self): # <<<<<<<<<<<<<< + * """Retrieve the depth of the current node""" + * return SCIPgetDepth(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getDepth", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1214 + * return SCIPgetDepth(self._scip) + * + * def infinity(self): # <<<<<<<<<<<<<< + * """Retrieve SCIP's infinity value""" + * return SCIPinfinity(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_59infinity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_58infinity, "Model.infinity(self)\nRetrieve SCIP's infinity value"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_59infinity = {"infinity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_59infinity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_58infinity}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_59infinity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("infinity (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("infinity", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "infinity", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_58infinity(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_58infinity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("infinity", 1); + + /* "src/pyscipopt/scip.pxi":1216 + * def infinity(self): + * """Retrieve SCIP's infinity value""" + * return SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * + * def epsilon(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1214 + * return SCIPgetDepth(self._scip) + * + * def infinity(self): # <<<<<<<<<<<<<< + * """Retrieve SCIP's infinity value""" + * return SCIPinfinity(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.infinity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1218 + * return SCIPinfinity(self._scip) + * + * def epsilon(self): # <<<<<<<<<<<<<< + * """Retrieve epsilon for e.g. equality checks""" + * return SCIPepsilon(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_61epsilon(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_60epsilon, "Model.epsilon(self)\nRetrieve epsilon for e.g. equality checks"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_61epsilon = {"epsilon", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_61epsilon, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_60epsilon}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_61epsilon(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("epsilon (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("epsilon", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "epsilon", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_60epsilon(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_60epsilon(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("epsilon", 1); + + /* "src/pyscipopt/scip.pxi":1220 + * def epsilon(self): + * """Retrieve epsilon for e.g. equality checks""" + * return SCIPepsilon(self._scip) # <<<<<<<<<<<<<< + * + * def feastol(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPepsilon(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1218 + * return SCIPinfinity(self._scip) + * + * def epsilon(self): # <<<<<<<<<<<<<< + * """Retrieve epsilon for e.g. equality checks""" + * return SCIPepsilon(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.epsilon", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1222 + * return SCIPepsilon(self._scip) + * + * def feastol(self): # <<<<<<<<<<<<<< + * """Retrieve feasibility tolerance""" + * return SCIPfeastol(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_63feastol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_62feastol, "Model.feastol(self)\nRetrieve feasibility tolerance"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_63feastol = {"feastol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_63feastol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_62feastol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_63feastol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feastol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("feastol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "feastol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_62feastol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_62feastol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("feastol", 1); + + /* "src/pyscipopt/scip.pxi":1224 + * def feastol(self): + * """Retrieve feasibility tolerance""" + * return SCIPfeastol(self._scip) # <<<<<<<<<<<<<< + * + * def feasFrac(self, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPfeastol(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1222 + * return SCIPepsilon(self._scip) + * + * def feastol(self): # <<<<<<<<<<<<<< + * """Retrieve feasibility tolerance""" + * return SCIPfeastol(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.feastol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1226 + * return SCIPfeastol(self._scip) + * + * def feasFrac(self, value): # <<<<<<<<<<<<<< + * """returns fractional part of value, i.e. x - floor(x) in feasible tolerance: x - floor(x+feastol)""" + * return SCIPfeasFrac(self._scip, value) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_65feasFrac(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_64feasFrac, "Model.feasFrac(self, value)\nreturns fractional part of value, i.e. x - floor(x) in feasible tolerance: x - floor(x+feastol)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_65feasFrac = {"feasFrac", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_65feasFrac, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_64feasFrac}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_65feasFrac(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("feasFrac (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1226, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "feasFrac") < 0)) __PYX_ERR(0, 1226, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("feasFrac", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1226, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.feasFrac", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_64feasFrac(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_64feasFrac(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("feasFrac", 1); + + /* "src/pyscipopt/scip.pxi":1228 + * def feasFrac(self, value): + * """returns fractional part of value, i.e. x - floor(x) in feasible tolerance: x - floor(x+feastol)""" + * return SCIPfeasFrac(self._scip, value) # <<<<<<<<<<<<<< + * + * def frac(self, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1228, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(SCIPfeasFrac(__pyx_v_self->_scip, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1226 + * return SCIPfeastol(self._scip) + * + * def feasFrac(self, value): # <<<<<<<<<<<<<< + * """returns fractional part of value, i.e. x - floor(x) in feasible tolerance: x - floor(x+feastol)""" + * return SCIPfeasFrac(self._scip, value) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.feasFrac", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1230 + * return SCIPfeasFrac(self._scip, value) + * + * def frac(self, value): # <<<<<<<<<<<<<< + * """returns fractional part of value, i.e. x - floor(x) in epsilon tolerance: x - floor(x+eps)""" + * return SCIPfrac(self._scip, value) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_67frac(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_66frac, "Model.frac(self, value)\nreturns fractional part of value, i.e. x - floor(x) in epsilon tolerance: x - floor(x+eps)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_67frac = {"frac", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_67frac, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_66frac}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_67frac(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("frac (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1230, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "frac") < 0)) __PYX_ERR(0, 1230, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("frac", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1230, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.frac", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_66frac(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_66frac(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("frac", 1); + + /* "src/pyscipopt/scip.pxi":1232 + * def frac(self, value): + * """returns fractional part of value, i.e. x - floor(x) in epsilon tolerance: x - floor(x+eps)""" + * return SCIPfrac(self._scip, value) # <<<<<<<<<<<<<< + * + * def isZero(self, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1232, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(SCIPfrac(__pyx_v_self->_scip, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1230 + * return SCIPfeasFrac(self._scip, value) + * + * def frac(self, value): # <<<<<<<<<<<<<< + * """returns fractional part of value, i.e. x - floor(x) in epsilon tolerance: x - floor(x+eps)""" + * return SCIPfrac(self._scip, value) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.frac", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1234 + * return SCIPfrac(self._scip, value) + * + * def isZero(self, value): # <<<<<<<<<<<<<< + * """returns whether abs(value) < eps""" + * return SCIPisZero(self._scip, value) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_69isZero(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_68isZero, "Model.isZero(self, value)\nreturns whether abs(value) < eps"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_69isZero = {"isZero", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_69isZero, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_68isZero}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_69isZero(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isZero (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1234, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isZero") < 0)) __PYX_ERR(0, 1234, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isZero", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1234, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isZero", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_68isZero(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_68isZero(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isZero", 1); + + /* "src/pyscipopt/scip.pxi":1236 + * def isZero(self, value): + * """returns whether abs(value) < eps""" + * return SCIPisZero(self._scip, value) # <<<<<<<<<<<<<< + * + * def isFeasZero(self, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1236, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(SCIPisZero(__pyx_v_self->_scip, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1234 + * return SCIPfrac(self._scip, value) + * + * def isZero(self, value): # <<<<<<<<<<<<<< + * """returns whether abs(value) < eps""" + * return SCIPisZero(self._scip, value) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.isZero", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1238 + * return SCIPisZero(self._scip, value) + * + * def isFeasZero(self, value): # <<<<<<<<<<<<<< + * """returns whether abs(value) < feastol""" + * return SCIPisFeasZero(self._scip, value) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_71isFeasZero(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_70isFeasZero, "Model.isFeasZero(self, value)\nreturns whether abs(value) < feastol"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_71isFeasZero = {"isFeasZero", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_71isFeasZero, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_70isFeasZero}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_71isFeasZero(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isFeasZero (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1238, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isFeasZero") < 0)) __PYX_ERR(0, 1238, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isFeasZero", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1238, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isFeasZero", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_70isFeasZero(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_70isFeasZero(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isFeasZero", 1); + + /* "src/pyscipopt/scip.pxi":1240 + * def isFeasZero(self, value): + * """returns whether abs(value) < feastol""" + * return SCIPisFeasZero(self._scip, value) # <<<<<<<<<<<<<< + * + * def isInfinity(self, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1240, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(SCIPisFeasZero(__pyx_v_self->_scip, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1238 + * return SCIPisZero(self._scip, value) + * + * def isFeasZero(self, value): # <<<<<<<<<<<<<< + * """returns whether abs(value) < feastol""" + * return SCIPisFeasZero(self._scip, value) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.isFeasZero", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1242 + * return SCIPisFeasZero(self._scip, value) + * + * def isInfinity(self, value): # <<<<<<<<<<<<<< + * """returns whether value is SCIP's infinity""" + * return SCIPisInfinity(self._scip, value) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_73isInfinity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_72isInfinity, "Model.isInfinity(self, value)\nreturns whether value is SCIP's infinity"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_73isInfinity = {"isInfinity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_73isInfinity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_72isInfinity}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_73isInfinity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isInfinity (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1242, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isInfinity") < 0)) __PYX_ERR(0, 1242, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isInfinity", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1242, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isInfinity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_72isInfinity(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_72isInfinity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isInfinity", 1); + + /* "src/pyscipopt/scip.pxi":1244 + * def isInfinity(self, value): + * """returns whether value is SCIP's infinity""" + * return SCIPisInfinity(self._scip, value) # <<<<<<<<<<<<<< + * + * def isFeasNegative(self, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1244, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(SCIPisInfinity(__pyx_v_self->_scip, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1242 + * return SCIPisFeasZero(self._scip, value) + * + * def isInfinity(self, value): # <<<<<<<<<<<<<< + * """returns whether value is SCIP's infinity""" + * return SCIPisInfinity(self._scip, value) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.isInfinity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1246 + * return SCIPisInfinity(self._scip, value) + * + * def isFeasNegative(self, value): # <<<<<<<<<<<<<< + * """returns whether value < -feastol""" + * return SCIPisFeasNegative(self._scip, value) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_75isFeasNegative(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_74isFeasNegative, "Model.isFeasNegative(self, value)\nreturns whether value < -feastol"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_75isFeasNegative = {"isFeasNegative", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_75isFeasNegative, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_74isFeasNegative}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_75isFeasNegative(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isFeasNegative (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1246, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isFeasNegative") < 0)) __PYX_ERR(0, 1246, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isFeasNegative", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1246, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isFeasNegative", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_74isFeasNegative(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_74isFeasNegative(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isFeasNegative", 1); + + /* "src/pyscipopt/scip.pxi":1248 + * def isFeasNegative(self, value): + * """returns whether value < -feastol""" + * return SCIPisFeasNegative(self._scip, value) # <<<<<<<<<<<<<< + * + * def isFeasIntegral(self, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1248, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(SCIPisFeasNegative(__pyx_v_self->_scip, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1246 + * return SCIPisInfinity(self._scip, value) + * + * def isFeasNegative(self, value): # <<<<<<<<<<<<<< + * """returns whether value < -feastol""" + * return SCIPisFeasNegative(self._scip, value) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.isFeasNegative", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1250 + * return SCIPisFeasNegative(self._scip, value) + * + * def isFeasIntegral(self, value): # <<<<<<<<<<<<<< + * """returns whether value is integral within the LP feasibility bounds""" + * return SCIPisFeasIntegral(self._scip, value) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_77isFeasIntegral(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_76isFeasIntegral, "Model.isFeasIntegral(self, value)\nreturns whether value is integral within the LP feasibility bounds"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_77isFeasIntegral = {"isFeasIntegral", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_77isFeasIntegral, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_76isFeasIntegral}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_77isFeasIntegral(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isFeasIntegral (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1250, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isFeasIntegral") < 0)) __PYX_ERR(0, 1250, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isFeasIntegral", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1250, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isFeasIntegral", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_76isFeasIntegral(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_76isFeasIntegral(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isFeasIntegral", 1); + + /* "src/pyscipopt/scip.pxi":1252 + * def isFeasIntegral(self, value): + * """returns whether value is integral within the LP feasibility bounds""" + * return SCIPisFeasIntegral(self._scip, value) # <<<<<<<<<<<<<< + * + * def isEQ(self, val1, val2): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1252, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(SCIPisFeasIntegral(__pyx_v_self->_scip, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1250 + * return SCIPisFeasNegative(self._scip, value) + * + * def isFeasIntegral(self, value): # <<<<<<<<<<<<<< + * """returns whether value is integral within the LP feasibility bounds""" + * return SCIPisFeasIntegral(self._scip, value) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.isFeasIntegral", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1254 + * return SCIPisFeasIntegral(self._scip, value) + * + * def isEQ(self, val1, val2): # <<<<<<<<<<<<<< + * """checks, if values are in range of epsilon""" + * return SCIPisEQ(self._scip, val1, val2) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_79isEQ(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_78isEQ, "Model.isEQ(self, val1, val2)\nchecks, if values are in range of epsilon"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_79isEQ = {"isEQ", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_79isEQ, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_78isEQ}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_79isEQ(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_val1 = 0; + PyObject *__pyx_v_val2 = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isEQ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_val1,&__pyx_n_s_val2,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val1)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1254, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val2)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1254, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("isEQ", 1, 2, 2, 1); __PYX_ERR(0, 1254, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isEQ") < 0)) __PYX_ERR(0, 1254, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_val1 = values[0]; + __pyx_v_val2 = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isEQ", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1254, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isEQ", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_78isEQ(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_val1, __pyx_v_val2); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_78isEQ(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isEQ", 1); + + /* "src/pyscipopt/scip.pxi":1256 + * def isEQ(self, val1, val2): + * """checks, if values are in range of epsilon""" + * return SCIPisEQ(self._scip, val1, val2) # <<<<<<<<<<<<<< + * + * def isFeasEQ(self, val1, val2): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val1); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1256, __pyx_L1_error) + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_val2); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1256, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(SCIPisEQ(__pyx_v_self->_scip, __pyx_t_1, __pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1254 + * return SCIPisFeasIntegral(self._scip, value) + * + * def isEQ(self, val1, val2): # <<<<<<<<<<<<<< + * """checks, if values are in range of epsilon""" + * return SCIPisEQ(self._scip, val1, val2) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.isEQ", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1258 + * return SCIPisEQ(self._scip, val1, val2) + * + * def isFeasEQ(self, val1, val2): # <<<<<<<<<<<<<< + * """checks, if relative difference of values is in range of feasibility tolerance""" + * return SCIPisFeasEQ(self._scip, val1, val2) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_81isFeasEQ(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_80isFeasEQ, "Model.isFeasEQ(self, val1, val2)\nchecks, if relative difference of values is in range of feasibility tolerance"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_81isFeasEQ = {"isFeasEQ", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_81isFeasEQ, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_80isFeasEQ}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_81isFeasEQ(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_val1 = 0; + PyObject *__pyx_v_val2 = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isFeasEQ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_val1,&__pyx_n_s_val2,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val1)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1258, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val2)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1258, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("isFeasEQ", 1, 2, 2, 1); __PYX_ERR(0, 1258, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isFeasEQ") < 0)) __PYX_ERR(0, 1258, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_val1 = values[0]; + __pyx_v_val2 = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isFeasEQ", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1258, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isFeasEQ", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_80isFeasEQ(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_val1, __pyx_v_val2); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_80isFeasEQ(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isFeasEQ", 1); + + /* "src/pyscipopt/scip.pxi":1260 + * def isFeasEQ(self, val1, val2): + * """checks, if relative difference of values is in range of feasibility tolerance""" + * return SCIPisFeasEQ(self._scip, val1, val2) # <<<<<<<<<<<<<< + * + * def isLE(self, val1, val2): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val1); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1260, __pyx_L1_error) + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_val2); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1260, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(SCIPisFeasEQ(__pyx_v_self->_scip, __pyx_t_1, __pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1258 + * return SCIPisEQ(self._scip, val1, val2) + * + * def isFeasEQ(self, val1, val2): # <<<<<<<<<<<<<< + * """checks, if relative difference of values is in range of feasibility tolerance""" + * return SCIPisFeasEQ(self._scip, val1, val2) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.isFeasEQ", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1262 + * return SCIPisFeasEQ(self._scip, val1, val2) + * + * def isLE(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 <= val2 + eps""" + * return SCIPisLE(self._scip, val1, val2) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_83isLE(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_82isLE, "Model.isLE(self, val1, val2)\nreturns whether val1 <= val2 + eps"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_83isLE = {"isLE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_83isLE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_82isLE}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_83isLE(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_val1 = 0; + PyObject *__pyx_v_val2 = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isLE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_val1,&__pyx_n_s_val2,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val1)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1262, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val2)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1262, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("isLE", 1, 2, 2, 1); __PYX_ERR(0, 1262, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isLE") < 0)) __PYX_ERR(0, 1262, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_val1 = values[0]; + __pyx_v_val2 = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isLE", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1262, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isLE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_82isLE(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_val1, __pyx_v_val2); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_82isLE(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isLE", 1); + + /* "src/pyscipopt/scip.pxi":1264 + * def isLE(self, val1, val2): + * """returns whether val1 <= val2 + eps""" + * return SCIPisLE(self._scip, val1, val2) # <<<<<<<<<<<<<< + * + * def isLT(self, val1, val2): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val1); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1264, __pyx_L1_error) + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_val2); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1264, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(SCIPisLE(__pyx_v_self->_scip, __pyx_t_1, __pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1262 + * return SCIPisFeasEQ(self._scip, val1, val2) + * + * def isLE(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 <= val2 + eps""" + * return SCIPisLE(self._scip, val1, val2) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.isLE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1266 + * return SCIPisLE(self._scip, val1, val2) + * + * def isLT(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 < val2 - eps""" + * return SCIPisLT(self._scip, val1, val2) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_85isLT(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_84isLT, "Model.isLT(self, val1, val2)\nreturns whether val1 < val2 - eps"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_85isLT = {"isLT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_85isLT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_84isLT}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_85isLT(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_val1 = 0; + PyObject *__pyx_v_val2 = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isLT (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_val1,&__pyx_n_s_val2,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val1)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1266, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val2)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1266, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("isLT", 1, 2, 2, 1); __PYX_ERR(0, 1266, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isLT") < 0)) __PYX_ERR(0, 1266, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_val1 = values[0]; + __pyx_v_val2 = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isLT", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1266, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isLT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_84isLT(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_val1, __pyx_v_val2); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_84isLT(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isLT", 1); + + /* "src/pyscipopt/scip.pxi":1268 + * def isLT(self, val1, val2): + * """returns whether val1 < val2 - eps""" + * return SCIPisLT(self._scip, val1, val2) # <<<<<<<<<<<<<< + * + * def isGE(self, val1, val2): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val1); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1268, __pyx_L1_error) + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_val2); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1268, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(SCIPisLT(__pyx_v_self->_scip, __pyx_t_1, __pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1266 + * return SCIPisLE(self._scip, val1, val2) + * + * def isLT(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 < val2 - eps""" + * return SCIPisLT(self._scip, val1, val2) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.isLT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1270 + * return SCIPisLT(self._scip, val1, val2) + * + * def isGE(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 >= val2 - eps""" + * return SCIPisGE(self._scip, val1, val2) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_87isGE(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_86isGE, "Model.isGE(self, val1, val2)\nreturns whether val1 >= val2 - eps"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_87isGE = {"isGE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_87isGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_86isGE}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_87isGE(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_val1 = 0; + PyObject *__pyx_v_val2 = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isGE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_val1,&__pyx_n_s_val2,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val1)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1270, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val2)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1270, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("isGE", 1, 2, 2, 1); __PYX_ERR(0, 1270, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isGE") < 0)) __PYX_ERR(0, 1270, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_val1 = values[0]; + __pyx_v_val2 = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isGE", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1270, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isGE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_86isGE(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_val1, __pyx_v_val2); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_86isGE(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isGE", 1); + + /* "src/pyscipopt/scip.pxi":1272 + * def isGE(self, val1, val2): + * """returns whether val1 >= val2 - eps""" + * return SCIPisGE(self._scip, val1, val2) # <<<<<<<<<<<<<< + * + * def isGT(self, val1, val2): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val1); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1272, __pyx_L1_error) + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_val2); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1272, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(SCIPisGE(__pyx_v_self->_scip, __pyx_t_1, __pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1270 + * return SCIPisLT(self._scip, val1, val2) + * + * def isGE(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 >= val2 - eps""" + * return SCIPisGE(self._scip, val1, val2) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.isGE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1274 + * return SCIPisGE(self._scip, val1, val2) + * + * def isGT(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 > val2 + eps""" + * return SCIPisGT(self._scip, val1, val2) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_89isGT(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_88isGT, "Model.isGT(self, val1, val2)\nreturns whether val1 > val2 + eps"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_89isGT = {"isGT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_89isGT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_88isGT}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_89isGT(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_val1 = 0; + PyObject *__pyx_v_val2 = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isGT (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_val1,&__pyx_n_s_val2,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val1)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1274, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val2)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1274, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("isGT", 1, 2, 2, 1); __PYX_ERR(0, 1274, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isGT") < 0)) __PYX_ERR(0, 1274, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_val1 = values[0]; + __pyx_v_val2 = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isGT", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1274, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isGT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_88isGT(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_val1, __pyx_v_val2); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_88isGT(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_val1, PyObject *__pyx_v_val2) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isGT", 1); + + /* "src/pyscipopt/scip.pxi":1276 + * def isGT(self, val1, val2): + * """returns whether val1 > val2 + eps""" + * return SCIPisGT(self._scip, val1, val2) # <<<<<<<<<<<<<< + * + * def getCondition(self, exact=False): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val1); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1276, __pyx_L1_error) + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_val2); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1276, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyBool_FromLong(SCIPisGT(__pyx_v_self->_scip, __pyx_t_1, __pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1274 + * return SCIPisGE(self._scip, val1, val2) + * + * def isGT(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 > val2 + eps""" + * return SCIPisGT(self._scip, val1, val2) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.isGT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1278 + * return SCIPisGT(self._scip, val1, val2) + * + * def getCondition(self, exact=False): # <<<<<<<<<<<<<< + * """Get the current LP's condition number + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_91getCondition(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_90getCondition, "Model.getCondition(self, exact=False)\nGet the current LP's condition number\n\n :param exact: whether to get an estimate or the exact value (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_91getCondition = {"getCondition", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_91getCondition, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_90getCondition}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_91getCondition(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_exact = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getCondition (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_exact,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_exact); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1278, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getCondition") < 0)) __PYX_ERR(0, 1278, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_exact = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getCondition", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1278, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getCondition", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_90getCondition(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_exact); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_90getCondition(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_exact) { + SCIP_LPI *__pyx_v_lpi; + SCIP_Real __pyx_v_quality; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getCondition", 1); + + /* "src/pyscipopt/scip.pxi":1285 + * """ + * cdef SCIP_LPI* lpi + * PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi)) # <<<<<<<<<<<<<< + * cdef SCIP_Real quality = 0 + * if exact: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetLPI(__pyx_v_self->_scip, (&__pyx_v_lpi))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1286 + * cdef SCIP_LPI* lpi + * PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi)) + * cdef SCIP_Real quality = 0 # <<<<<<<<<<<<<< + * if exact: + * PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_EXACTCONDITION, &quality)) + */ + __pyx_v_quality = 0.0; + + /* "src/pyscipopt/scip.pxi":1287 + * PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi)) + * cdef SCIP_Real quality = 0 + * if exact: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_EXACTCONDITION, &quality)) + * else: + */ + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_exact); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 1287, __pyx_L1_error) + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":1288 + * cdef SCIP_Real quality = 0 + * if exact: + * PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_EXACTCONDITION, &quality)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_ESTIMCONDITION, &quality)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetRealSolQuality(__pyx_v_lpi, SCIP_LPSOLQUALITY_EXACTCONDITION, (&__pyx_v_quality))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1287 + * PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi)) + * cdef SCIP_Real quality = 0 + * if exact: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_EXACTCONDITION, &quality)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":1290 + * PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_EXACTCONDITION, &quality)) + * else: + * PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_ESTIMCONDITION, &quality)) # <<<<<<<<<<<<<< + * + * return quality + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetRealSolQuality(__pyx_v_lpi, SCIP_LPSOLQUALITY_ESTIMCONDITION, (&__pyx_v_quality))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":1292 + * PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_ESTIMCONDITION, &quality)) + * + * return quality # <<<<<<<<<<<<<< + * + * def enableReoptimization(self, enable=True): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_quality); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1278 + * return SCIPisGT(self._scip, val1, val2) + * + * def getCondition(self, exact=False): # <<<<<<<<<<<<<< + * """Get the current LP's condition number + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getCondition", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1294 + * return quality + * + * def enableReoptimization(self, enable=True): # <<<<<<<<<<<<<< + * """include specific heuristics and branching rules for reoptimization""" + * PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_93enableReoptimization(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_92enableReoptimization, "Model.enableReoptimization(self, enable=True)\ninclude specific heuristics and branching rules for reoptimization"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_93enableReoptimization = {"enableReoptimization", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_93enableReoptimization, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_92enableReoptimization}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_93enableReoptimization(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_enable = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("enableReoptimization (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_enable,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enable); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1294, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "enableReoptimization") < 0)) __PYX_ERR(0, 1294, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_enable = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("enableReoptimization", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1294, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.enableReoptimization", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_92enableReoptimization(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_enable); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_92enableReoptimization(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_enable) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Bool __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("enableReoptimization", 1); + + /* "src/pyscipopt/scip.pxi":1296 + * def enableReoptimization(self, enable=True): + * """include specific heuristics and branching rules for reoptimization""" + * PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable)) # <<<<<<<<<<<<<< + * + * def lpiGetIterations(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_enable); if (unlikely((__pyx_t_3 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1296, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPenableReoptimization(__pyx_v_self->_scip, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1294 + * return quality + * + * def enableReoptimization(self, enable=True): # <<<<<<<<<<<<<< + * """include specific heuristics and branching rules for reoptimization""" + * PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.enableReoptimization", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1298 + * PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable)) + * + * def lpiGetIterations(self): # <<<<<<<<<<<<<< + * """Get the iteration count of the last solved LP""" + * cdef SCIP_LPI* lpi + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_95lpiGetIterations(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_94lpiGetIterations, "Model.lpiGetIterations(self)\nGet the iteration count of the last solved LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_95lpiGetIterations = {"lpiGetIterations", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_95lpiGetIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_94lpiGetIterations}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_95lpiGetIterations(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lpiGetIterations (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("lpiGetIterations", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "lpiGetIterations", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_94lpiGetIterations(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_94lpiGetIterations(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_LPI *__pyx_v_lpi; + int __pyx_v_iters; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lpiGetIterations", 1); + + /* "src/pyscipopt/scip.pxi":1301 + * """Get the iteration count of the last solved LP""" + * cdef SCIP_LPI* lpi + * PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi)) # <<<<<<<<<<<<<< + * cdef int iters = 0 + * PY_SCIP_CALL(SCIPlpiGetIterations(lpi, &iters)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetLPI(__pyx_v_self->_scip, (&__pyx_v_lpi))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1302 + * cdef SCIP_LPI* lpi + * PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi)) + * cdef int iters = 0 # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPlpiGetIterations(lpi, &iters)) + * return iters + */ + __pyx_v_iters = 0; + + /* "src/pyscipopt/scip.pxi":1303 + * PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi)) + * cdef int iters = 0 + * PY_SCIP_CALL(SCIPlpiGetIterations(lpi, &iters)) # <<<<<<<<<<<<<< + * return iters + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1303, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPlpiGetIterations(__pyx_v_lpi, (&__pyx_v_iters))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1303, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1303, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1304 + * cdef int iters = 0 + * PY_SCIP_CALL(SCIPlpiGetIterations(lpi, &iters)) + * return iters # <<<<<<<<<<<<<< + * + * # Objective function + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_iters); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1298 + * PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable)) + * + * def lpiGetIterations(self): # <<<<<<<<<<<<<< + * """Get the iteration count of the last solved LP""" + * cdef SCIP_LPI* lpi + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.lpiGetIterations", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1308 + * # Objective function + * + * def setMinimize(self): # <<<<<<<<<<<<<< + * """Set the objective sense to minimization.""" + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_97setMinimize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_96setMinimize, "Model.setMinimize(self)\nSet the objective sense to minimization."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_97setMinimize = {"setMinimize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_97setMinimize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_96setMinimize}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_97setMinimize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setMinimize (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("setMinimize", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setMinimize", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_96setMinimize(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_96setMinimize(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setMinimize", 1); + + /* "src/pyscipopt/scip.pxi":1310 + * def setMinimize(self): + * """Set the objective sense to minimization.""" + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE)) # <<<<<<<<<<<<<< + * + * def setMaximize(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetObjsense(__pyx_v_self->_scip, SCIP_OBJSENSE_MINIMIZE)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1308 + * # Objective function + * + * def setMinimize(self): # <<<<<<<<<<<<<< + * """Set the objective sense to minimization.""" + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.setMinimize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1312 + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE)) + * + * def setMaximize(self): # <<<<<<<<<<<<<< + * """Set the objective sense to maximization.""" + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_99setMaximize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_98setMaximize, "Model.setMaximize(self)\nSet the objective sense to maximization."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_99setMaximize = {"setMaximize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_99setMaximize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_98setMaximize}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_99setMaximize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setMaximize (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("setMaximize", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setMaximize", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_98setMaximize(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_98setMaximize(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setMaximize", 1); + + /* "src/pyscipopt/scip.pxi":1314 + * def setMaximize(self): + * """Set the objective sense to maximization.""" + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE)) # <<<<<<<<<<<<<< + * + * def setObjlimit(self, objlimit): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetObjsense(__pyx_v_self->_scip, SCIP_OBJSENSE_MAXIMIZE)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1312 + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE)) + * + * def setMaximize(self): # <<<<<<<<<<<<<< + * """Set the objective sense to maximization.""" + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.setMaximize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1316 + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE)) + * + * def setObjlimit(self, objlimit): # <<<<<<<<<<<<<< + * """Set a limit on the objective function. + * Only solutions with objective value better than this limit are accepted. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_101setObjlimit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_100setObjlimit, "Model.setObjlimit(self, objlimit)\nSet a limit on the objective function.\n Only solutions with objective value better than this limit are accepted.\n\n :param objlimit: limit on the objective function\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_101setObjlimit = {"setObjlimit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_101setObjlimit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_100setObjlimit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_101setObjlimit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_objlimit = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setObjlimit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_objlimit,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_objlimit)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1316, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setObjlimit") < 0)) __PYX_ERR(0, 1316, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_objlimit = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setObjlimit", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1316, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setObjlimit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_100setObjlimit(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_objlimit); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_100setObjlimit(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_objlimit) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setObjlimit", 1); + + /* "src/pyscipopt/scip.pxi":1323 + * + * """ + * PY_SCIP_CALL(SCIPsetObjlimit(self._scip, objlimit)) # <<<<<<<<<<<<<< + * + * def getObjlimit(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_objlimit); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1323, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetObjlimit(__pyx_v_self->_scip, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1316 + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE)) + * + * def setObjlimit(self, objlimit): # <<<<<<<<<<<<<< + * """Set a limit on the objective function. + * Only solutions with objective value better than this limit are accepted. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setObjlimit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1325 + * PY_SCIP_CALL(SCIPsetObjlimit(self._scip, objlimit)) + * + * def getObjlimit(self): # <<<<<<<<<<<<<< + * """returns current limit on objective function.""" + * return SCIPgetObjlimit(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_103getObjlimit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_102getObjlimit, "Model.getObjlimit(self)\nreturns current limit on objective function."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_103getObjlimit = {"getObjlimit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_103getObjlimit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_102getObjlimit}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_103getObjlimit(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getObjlimit (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getObjlimit", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getObjlimit", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_102getObjlimit(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_102getObjlimit(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getObjlimit", 1); + + /* "src/pyscipopt/scip.pxi":1327 + * def getObjlimit(self): + * """returns current limit on objective function.""" + * return SCIPgetObjlimit(self._scip) # <<<<<<<<<<<<<< + * + * def setObjective(self, expr, sense = 'minimize', clear = 'true'): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetObjlimit(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1327, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1325 + * PY_SCIP_CALL(SCIPsetObjlimit(self._scip, objlimit)) + * + * def getObjlimit(self): # <<<<<<<<<<<<<< + * """returns current limit on objective function.""" + * return SCIPgetObjlimit(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getObjlimit", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1329 + * return SCIPgetObjlimit(self._scip) + * + * def setObjective(self, expr, sense = 'minimize', clear = 'true'): # <<<<<<<<<<<<<< + * """Establish the objective function as a linear expression. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_105setObjective(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_104setObjective, "Model.setObjective(self, expr, sense=u'minimize', clear=u'true')\nEstablish the objective function as a linear expression.\n\n :param expr: the objective function SCIP Expr, or constant value\n :param sense: the objective sense (Default value = 'minimize')\n :param clear: set all other variables objective coefficient to zero (Default value = 'true')\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_105setObjective = {"setObjective", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_105setObjective, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_104setObjective}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_105setObjective(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_expr = 0; + PyObject *__pyx_v_sense = 0; + PyObject *__pyx_v_clear = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setObjective (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,&__pyx_n_s_sense,&__pyx_n_s_clear,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_minimize)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_true)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1329, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sense); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1329, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_clear); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1329, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setObjective") < 0)) __PYX_ERR(0, 1329, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_expr = values[0]; + __pyx_v_sense = values[1]; + __pyx_v_clear = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setObjective", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 1329, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setObjective", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_104setObjective(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_expr, __pyx_v_sense, __pyx_v_clear); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_104setObjective(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_expr, PyObject *__pyx_v_sense, PyObject *__pyx_v_clear) { + SCIP_VAR **__pyx_v__vars; + int __pyx_v__nvars; + int __pyx_v_i; + PyObject *__pyx_v_term = NULL; + PyObject *__pyx_v_coef = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + Py_ssize_t __pyx_t_14; + SCIP_Real __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setObjective", 0); + __Pyx_INCREF(__pyx_v_expr); + + /* "src/pyscipopt/scip.pxi":1342 + * + * # turn the constant value into an Expr instance for further processing + * if not isinstance(expr, Expr): # <<<<<<<<<<<<<< + * assert(_is_number(expr)), "given coefficients are neither Expr or number but %s" % expr.__class__.__name__ + * expr = Expr() + expr + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_expr, __pyx_ptype_9pyscipopt_4scip_Expr); + __pyx_t_2 = (!__pyx_t_1); + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1343 + * # turn the constant value into an Expr instance for further processing + * if not isinstance(expr, Expr): + * assert(_is_number(expr)), "given coefficients are neither Expr or number but %s" % expr.__class__.__name__ # <<<<<<<<<<<<<< + * expr = Expr() + expr + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_is_number); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_expr}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1343, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_given_coefficients_are_neither_E, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_3, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1343, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 1343, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":1344 + * if not isinstance(expr, Expr): + * assert(_is_number(expr)), "given coefficients are neither Expr or number but %s" % expr.__class__.__name__ + * expr = Expr() + expr # <<<<<<<<<<<<<< + * + * if expr.degree() > 1: + */ + __pyx_t_3 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_v_expr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_expr, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1342 + * + * # turn the constant value into an Expr instance for further processing + * if not isinstance(expr, Expr): # <<<<<<<<<<<<<< + * assert(_is_number(expr)), "given coefficients are neither Expr or number but %s" % expr.__class__.__name__ + * expr = Expr() + expr + */ + } + + /* "src/pyscipopt/scip.pxi":1346 + * expr = Expr() + expr + * + * if expr.degree() > 1: # <<<<<<<<<<<<<< + * raise ValueError("SCIP does not support nonlinear objective functions. Consider using set_nonlinear_objective in the pyscipopt.recipe.nonlinear") + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_degree); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_int_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1346, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1346, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_2)) { + + /* "src/pyscipopt/scip.pxi":1347 + * + * if expr.degree() > 1: + * raise ValueError("SCIP does not support nonlinear objective functions. Consider using set_nonlinear_objective in the pyscipopt.recipe.nonlinear") # <<<<<<<<<<<<<< + * + * if clear: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1347, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1346 + * expr = Expr() + expr + * + * if expr.degree() > 1: # <<<<<<<<<<<<<< + * raise ValueError("SCIP does not support nonlinear objective functions. Consider using set_nonlinear_objective in the pyscipopt.recipe.nonlinear") + * + */ + } + + /* "src/pyscipopt/scip.pxi":1349 + * raise ValueError("SCIP does not support nonlinear objective functions. Consider using set_nonlinear_objective in the pyscipopt.recipe.nonlinear") + * + * if clear: # <<<<<<<<<<<<<< + * # clear existing objective function + * self.addObjoffset(-self.getObjoffset()) + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_clear); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1349, __pyx_L1_error) + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1351 + * if clear: + * # clear existing objective function + * self.addObjoffset(-self.getObjoffset()) # <<<<<<<<<<<<<< + * _vars = SCIPgetOrigVars(self._scip) + * _nvars = SCIPgetNOrigVars(self._scip) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_addObjoffset); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getObjoffset); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_7 = PyNumber_Negative(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1352 + * # clear existing objective function + * self.addObjoffset(-self.getObjoffset()) + * _vars = SCIPgetOrigVars(self._scip) # <<<<<<<<<<<<<< + * _nvars = SCIPgetNOrigVars(self._scip) + * for i in range(_nvars): + */ + __pyx_v__vars = SCIPgetOrigVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":1353 + * self.addObjoffset(-self.getObjoffset()) + * _vars = SCIPgetOrigVars(self._scip) + * _nvars = SCIPgetNOrigVars(self._scip) # <<<<<<<<<<<<<< + * for i in range(_nvars): + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, _vars[i], 0.0)) + */ + __pyx_v__nvars = SCIPgetNOrigVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":1354 + * _vars = SCIPgetOrigVars(self._scip) + * _nvars = SCIPgetNOrigVars(self._scip) + * for i in range(_nvars): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, _vars[i], 0.0)) + * + */ + __pyx_t_6 = __pyx_v__nvars; + __pyx_t_9 = __pyx_t_6; + for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { + __pyx_v_i = __pyx_t_10; + + /* "src/pyscipopt/scip.pxi":1355 + * _nvars = SCIPgetNOrigVars(self._scip) + * for i in range(_nvars): + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, _vars[i], 0.0)) # <<<<<<<<<<<<<< + * + * if expr[CONST] != 0.0: + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarObj(__pyx_v_self->_scip, (__pyx_v__vars[__pyx_v_i]), 0.0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + + /* "src/pyscipopt/scip.pxi":1349 + * raise ValueError("SCIP does not support nonlinear objective functions. Consider using set_nonlinear_objective in the pyscipopt.recipe.nonlinear") + * + * if clear: # <<<<<<<<<<<<<< + * # clear existing objective function + * self.addObjoffset(-self.getObjoffset()) + */ + } + + /* "src/pyscipopt/scip.pxi":1357 + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, _vars[i], 0.0)) + * + * if expr[CONST] != 0.0: # <<<<<<<<<<<<<< + * self.addObjoffset(expr[CONST]) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_CONST); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_expr, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = (__Pyx_PyFloat_BoolNeObjC(__pyx_t_4, __pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1357, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1358 + * + * if expr[CONST] != 0.0: + * self.addObjoffset(expr[CONST]) # <<<<<<<<<<<<<< + * + * for term, coef in expr.terms.items(): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_addObjoffset); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_CONST); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_expr, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1357 + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, _vars[i], 0.0)) + * + * if expr[CONST] != 0.0: # <<<<<<<<<<<<<< + * self.addObjoffset(expr[CONST]) + * + */ + } + + /* "src/pyscipopt/scip.pxi":1360 + * self.addObjoffset(expr[CONST]) + * + * for term, coef in expr.terms.items(): # <<<<<<<<<<<<<< + * # avoid CONST term of Expr + * if term != CONST: + */ + __pyx_t_12 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_expr, __pyx_n_s_terms); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1360, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_t_3 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 1360, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_t_3, 0, __pyx_n_s_items, (&__pyx_t_13), (&__pyx_t_6)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1360, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); + __pyx_t_4 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_4, __pyx_t_13, &__pyx_t_12, &__pyx_t_5, &__pyx_t_3, NULL, __pyx_t_6); + if (unlikely(__pyx_t_9 == 0)) break; + if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 1360, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_term, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_coef, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1362 + * for term, coef in expr.terms.items(): + * # avoid CONST term of Expr + * if term != CONST: # <<<<<<<<<<<<<< + * assert len(term) == 1 + * var = term[0] + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_CONST); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyObject_RichCompare(__pyx_v_term, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1362, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1362, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1363 + * # avoid CONST term of Expr + * if term != CONST: + * assert len(term) == 1 # <<<<<<<<<<<<<< + * var = term[0] + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, var.scip_var, coef)) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_14 = PyObject_Length(__pyx_v_term); if (unlikely(__pyx_t_14 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1363, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_14 == 1); + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 1363, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 1363, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":1364 + * if term != CONST: + * assert len(term) == 1 + * var = term[0] # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, var.scip_var, coef)) + * + */ + __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_term, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1365 + * assert len(term) == 1 + * var = term[0] + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, var.scip_var, coef)) # <<<<<<<<<<<<<< + * + * if sense == "minimize": + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_15 = __pyx_PyFloat_AsDouble(__pyx_v_coef); if (unlikely((__pyx_t_15 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1365, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarObj(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_15)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1362 + * for term, coef in expr.terms.items(): + * # avoid CONST term of Expr + * if term != CONST: # <<<<<<<<<<<<<< + * assert len(term) == 1 + * var = term[0] + */ + } + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1367 + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, var.scip_var, coef)) + * + * if sense == "minimize": # <<<<<<<<<<<<<< + * self.setMinimize() + * elif sense == "maximize": + */ + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_sense, __pyx_n_u_minimize, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1367, __pyx_L1_error) + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1368 + * + * if sense == "minimize": + * self.setMinimize() # <<<<<<<<<<<<<< + * elif sense == "maximize": + * self.setMaximize() + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setMinimize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1367 + * PY_SCIP_CALL(SCIPchgVarObj(self._scip, var.scip_var, coef)) + * + * if sense == "minimize": # <<<<<<<<<<<<<< + * self.setMinimize() + * elif sense == "maximize": + */ + goto __pyx_L12; + } + + /* "src/pyscipopt/scip.pxi":1369 + * if sense == "minimize": + * self.setMinimize() + * elif sense == "maximize": # <<<<<<<<<<<<<< + * self.setMaximize() + * else: + */ + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_sense, __pyx_n_u_maximize, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1369, __pyx_L1_error) + if (likely(__pyx_t_2)) { + + /* "src/pyscipopt/scip.pxi":1370 + * self.setMinimize() + * elif sense == "maximize": + * self.setMaximize() # <<<<<<<<<<<<<< + * else: + * raise Warning("unrecognized optimization sense: %s" % sense) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setMaximize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1369 + * if sense == "minimize": + * self.setMinimize() + * elif sense == "maximize": # <<<<<<<<<<<<<< + * self.setMaximize() + * else: + */ + goto __pyx_L12; + } + + /* "src/pyscipopt/scip.pxi":1372 + * self.setMaximize() + * else: + * raise Warning("unrecognized optimization sense: %s" % sense) # <<<<<<<<<<<<<< + * + * def getObjective(self): + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unrecognized_optimization_sense, __pyx_v_sense); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1372, __pyx_L1_error) + } + __pyx_L12:; + + /* "src/pyscipopt/scip.pxi":1329 + * return SCIPgetObjlimit(self._scip) + * + * def setObjective(self, expr, sense = 'minimize', clear = 'true'): # <<<<<<<<<<<<<< + * """Establish the objective function as a linear expression. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.setObjective", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_term); + __Pyx_XDECREF(__pyx_v_coef); + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XDECREF(__pyx_v_expr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1374 + * raise Warning("unrecognized optimization sense: %s" % sense) + * + * def getObjective(self): # <<<<<<<<<<<<<< + * """Retrieve objective function as Expr""" + * variables = self.getVars() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_107getObjective(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_106getObjective, "Model.getObjective(self)\nRetrieve objective function as Expr"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_107getObjective = {"getObjective", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_107getObjective, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_106getObjective}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_107getObjective(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getObjective (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getObjective", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getObjective", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_106getObjective(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_106getObjective(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_v_variables = NULL; + PyObject *__pyx_v_objective = NULL; + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_v_coeff = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getObjective", 1); + + /* "src/pyscipopt/scip.pxi":1376 + * def getObjective(self): + * """Retrieve objective function as Expr""" + * variables = self.getVars() # <<<<<<<<<<<<<< + * objective = Expr() + * for var in variables: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getVars); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_variables = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1377 + * """Retrieve objective function as Expr""" + * variables = self.getVars() + * objective = Expr() # <<<<<<<<<<<<<< + * for var in variables: + * coeff = var.getObj() + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_objective = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1378 + * variables = self.getVars() + * objective = Expr() + * for var in variables: # <<<<<<<<<<<<<< + * coeff = var.getObj() + * if coeff != 0: + */ + if (likely(PyList_CheckExact(__pyx_v_variables)) || PyTuple_CheckExact(__pyx_v_variables)) { + __pyx_t_1 = __pyx_v_variables; __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_variables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1378, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1378, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 1378, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1378, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 1378, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_6(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 1378, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1379 + * objective = Expr() + * for var in variables: + * coeff = var.getObj() # <<<<<<<<<<<<<< + * if coeff != 0: + * objective += coeff * var + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_getObj); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_XDECREF_SET(__pyx_v_coeff, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1380 + * for var in variables: + * coeff = var.getObj() + * if coeff != 0: # <<<<<<<<<<<<<< + * objective += coeff * var + * objective.normalize() + */ + __pyx_t_8 = (__Pyx_PyInt_BoolNeObjC(__pyx_v_coeff, __pyx_int_0, 0, 0)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 1380, __pyx_L1_error) + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":1381 + * coeff = var.getObj() + * if coeff != 0: + * objective += coeff * var # <<<<<<<<<<<<<< + * objective.normalize() + * return objective + */ + __pyx_t_2 = PyNumber_Multiply(__pyx_v_coeff, __pyx_v_var); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_objective, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_objective, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1380 + * for var in variables: + * coeff = var.getObj() + * if coeff != 0: # <<<<<<<<<<<<<< + * objective += coeff * var + * objective.normalize() + */ + } + + /* "src/pyscipopt/scip.pxi":1378 + * variables = self.getVars() + * objective = Expr() + * for var in variables: # <<<<<<<<<<<<<< + * coeff = var.getObj() + * if coeff != 0: + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1382 + * if coeff != 0: + * objective += coeff * var + * objective.normalize() # <<<<<<<<<<<<<< + * return objective + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_objective, __pyx_n_s_normalize); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1383 + * objective += coeff * var + * objective.normalize() + * return objective # <<<<<<<<<<<<<< + * + * def addObjoffset(self, offset, solutions = False): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_objective); + __pyx_r = __pyx_v_objective; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1374 + * raise Warning("unrecognized optimization sense: %s" % sense) + * + * def getObjective(self): # <<<<<<<<<<<<<< + * """Retrieve objective function as Expr""" + * variables = self.getVars() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.getObjective", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_variables); + __Pyx_XDECREF(__pyx_v_objective); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XDECREF(__pyx_v_coeff); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1385 + * return objective + * + * def addObjoffset(self, offset, solutions = False): # <<<<<<<<<<<<<< + * """Add constant offset to objective + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_109addObjoffset(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_108addObjoffset, "Model.addObjoffset(self, offset, solutions=False)\nAdd constant offset to objective\n\n :param offset: offset to add\n :param solutions: add offset also to existing solutions (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_109addObjoffset = {"addObjoffset", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_109addObjoffset, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_108addObjoffset}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_109addObjoffset(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_offset = 0; + PyObject *__pyx_v_solutions = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addObjoffset (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_offset,&__pyx_n_s_solutions,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_offset)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1385, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solutions); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1385, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addObjoffset") < 0)) __PYX_ERR(0, 1385, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_offset = values[0]; + __pyx_v_solutions = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addObjoffset", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1385, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addObjoffset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_108addObjoffset(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_offset, __pyx_v_solutions); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_108addObjoffset(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_offset, PyObject *__pyx_v_solutions) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addObjoffset", 1); + + /* "src/pyscipopt/scip.pxi":1392 + * + * """ + * if solutions: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddObjoffset(self._scip, offset)) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_solutions); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1392, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1393 + * """ + * if solutions: + * PY_SCIP_CALL(SCIPaddObjoffset(self._scip, offset)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPaddOrigObjoffset(self._scip, offset)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_offset); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1393, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddObjoffset(__pyx_v_self->_scip, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1393, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1392 + * + * """ + * if solutions: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddObjoffset(self._scip, offset)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":1395 + * PY_SCIP_CALL(SCIPaddObjoffset(self._scip, offset)) + * else: + * PY_SCIP_CALL(SCIPaddOrigObjoffset(self._scip, offset)) # <<<<<<<<<<<<<< + * + * def getObjoffset(self, original = True): + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_offset); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1395, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddOrigObjoffset(__pyx_v_self->_scip, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1395, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":1385 + * return objective + * + * def addObjoffset(self, offset, solutions = False): # <<<<<<<<<<<<<< + * """Add constant offset to objective + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.addObjoffset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1397 + * PY_SCIP_CALL(SCIPaddOrigObjoffset(self._scip, offset)) + * + * def getObjoffset(self, original = True): # <<<<<<<<<<<<<< + * """Retrieve constant objective offset + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_111getObjoffset(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_110getObjoffset, "Model.getObjoffset(self, original=True)\nRetrieve constant objective offset\n\n :param original: offset of original or transformed problem (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_111getObjoffset = {"getObjoffset", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_111getObjoffset, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_110getObjoffset}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_111getObjoffset(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_original = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getObjoffset (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_original,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_original); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1397, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getObjoffset") < 0)) __PYX_ERR(0, 1397, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_original = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getObjoffset", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1397, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getObjoffset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_110getObjoffset(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_original); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_110getObjoffset(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_original) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getObjoffset", 1); + + /* "src/pyscipopt/scip.pxi":1403 + * + * """ + * if original: # <<<<<<<<<<<<<< + * return SCIPgetOrigObjoffset(self._scip) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_original); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1403, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1404 + * """ + * if original: + * return SCIPgetOrigObjoffset(self._scip) # <<<<<<<<<<<<<< + * else: + * return SCIPgetTransObjoffset(self._scip) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetOrigObjoffset(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1404, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1403 + * + * """ + * if original: # <<<<<<<<<<<<<< + * return SCIPgetOrigObjoffset(self._scip) + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":1406 + * return SCIPgetOrigObjoffset(self._scip) + * else: + * return SCIPgetTransObjoffset(self._scip) # <<<<<<<<<<<<<< + * + * def setObjIntegral(self): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetTransObjoffset(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":1397 + * PY_SCIP_CALL(SCIPaddOrigObjoffset(self._scip, offset)) + * + * def getObjoffset(self, original = True): # <<<<<<<<<<<<<< + * """Retrieve constant objective offset + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getObjoffset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1408 + * return SCIPgetTransObjoffset(self._scip) + * + * def setObjIntegral(self): # <<<<<<<<<<<<<< + * """informs SCIP that the objective value is always integral in every feasible solution + * Note: This function should be used to inform SCIP that the objective function is integral, helping to improve the + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_113setObjIntegral(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_112setObjIntegral, "Model.setObjIntegral(self)\ninforms SCIP that the objective value is always integral in every feasible solution\n Note: This function should be used to inform SCIP that the objective function is integral, helping to improve the\n performance. This is useful when using column generation. If no column generation (pricing) is used, SCIP\n automatically detects whether the objective function is integral or can be scaled to be integral. However, in\n any case, the user has to make sure that no variable is added during the solving process that destroys this\n property.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_113setObjIntegral = {"setObjIntegral", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_113setObjIntegral, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_112setObjIntegral}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_113setObjIntegral(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setObjIntegral (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("setObjIntegral", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setObjIntegral", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_112setObjIntegral(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_112setObjIntegral(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setObjIntegral", 1); + + /* "src/pyscipopt/scip.pxi":1416 + * property. + * """ + * PY_SCIP_CALL(SCIPsetObjIntegral(self._scip)) # <<<<<<<<<<<<<< + * + * def getLocalEstimate(self, original = False): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetObjIntegral(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1408 + * return SCIPgetTransObjoffset(self._scip) + * + * def setObjIntegral(self): # <<<<<<<<<<<<<< + * """informs SCIP that the objective value is always integral in every feasible solution + * Note: This function should be used to inform SCIP that the objective function is integral, helping to improve the + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.setObjIntegral", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1418 + * PY_SCIP_CALL(SCIPsetObjIntegral(self._scip)) + * + * def getLocalEstimate(self, original = False): # <<<<<<<<<<<<<< + * """gets estimate of best primal solution w.r.t. original or transformed problem contained in current subtree + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_115getLocalEstimate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_114getLocalEstimate, "Model.getLocalEstimate(self, original=False)\ngets estimate of best primal solution w.r.t. original or transformed problem contained in current subtree\n\n :param original: estimate of original or transformed problem (Default value = False)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_115getLocalEstimate = {"getLocalEstimate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_115getLocalEstimate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_114getLocalEstimate}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_115getLocalEstimate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_original = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLocalEstimate (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_original,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_original); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1418, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getLocalEstimate") < 0)) __PYX_ERR(0, 1418, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_original = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getLocalEstimate", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1418, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getLocalEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_114getLocalEstimate(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_original); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_114getLocalEstimate(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_original) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLocalEstimate", 1); + + /* "src/pyscipopt/scip.pxi":1423 + * :param original: estimate of original or transformed problem (Default value = False) + * """ + * if original: # <<<<<<<<<<<<<< + * return SCIPgetLocalOrigEstimate(self._scip) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_original); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1423, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1424 + * """ + * if original: + * return SCIPgetLocalOrigEstimate(self._scip) # <<<<<<<<<<<<<< + * else: + * return SCIPgetLocalTransEstimate(self._scip) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetLocalOrigEstimate(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1423 + * :param original: estimate of original or transformed problem (Default value = False) + * """ + * if original: # <<<<<<<<<<<<<< + * return SCIPgetLocalOrigEstimate(self._scip) + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":1426 + * return SCIPgetLocalOrigEstimate(self._scip) + * else: + * return SCIPgetLocalTransEstimate(self._scip) # <<<<<<<<<<<<<< + * + * # Setting parameters + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetLocalTransEstimate(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":1418 + * PY_SCIP_CALL(SCIPsetObjIntegral(self._scip)) + * + * def getLocalEstimate(self, original = False): # <<<<<<<<<<<<<< + * """gets estimate of best primal solution w.r.t. original or transformed problem contained in current subtree + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLocalEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1429 + * + * # Setting parameters + * def setPresolve(self, setting): # <<<<<<<<<<<<<< + * """Set presolving parameter settings. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_117setPresolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_116setPresolve, "Model.setPresolve(self, setting)\nSet presolving parameter settings.\n\n :param setting: the parameter settings (SCIP_PARAMSETTING)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_117setPresolve = {"setPresolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_117setPresolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_116setPresolve}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_117setPresolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_setting = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setPresolve (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_setting,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_setting)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1429, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setPresolve") < 0)) __PYX_ERR(0, 1429, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_setting = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setPresolve", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1429, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setPresolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_116setPresolve(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_setting); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_116setPresolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_setting) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_PARAMSETTING __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setPresolve", 1); + + /* "src/pyscipopt/scip.pxi":1435 + * + * """ + * PY_SCIP_CALL(SCIPsetPresolving(self._scip, setting, True)) # <<<<<<<<<<<<<< + * + * def setProbName(self, name): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_SCIP_PARAMSETTING(__pyx_v_setting); if (unlikely((__pyx_t_3 == ((SCIP_PARAMSETTING)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1435, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetPresolving(__pyx_v_self->_scip, __pyx_t_3, 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1429 + * + * # Setting parameters + * def setPresolve(self, setting): # <<<<<<<<<<<<<< + * """Set presolving parameter settings. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setPresolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1437 + * PY_SCIP_CALL(SCIPsetPresolving(self._scip, setting, True)) + * + * def setProbName(self, name): # <<<<<<<<<<<<<< + * """Set problem name""" + * n = str_conversion(name) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_119setProbName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_118setProbName, "Model.setProbName(self, name)\nSet problem name"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_119setProbName = {"setProbName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_119setProbName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_118setProbName}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_119setProbName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setProbName (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1437, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setProbName") < 0)) __PYX_ERR(0, 1437, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setProbName", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1437, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setProbName", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_118setProbName(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_118setProbName(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setProbName", 1); + + /* "src/pyscipopt/scip.pxi":1439 + * def setProbName(self, name): + * """Set problem name""" + * n = str_conversion(name) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetProbName(self._scip, n)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1440 + * """Set problem name""" + * n = str_conversion(name) + * PY_SCIP_CALL(SCIPsetProbName(self._scip, n)) # <<<<<<<<<<<<<< + * + * def setSeparating(self, setting): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 1440, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetProbName(__pyx_v_self->_scip, __pyx_t_5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1437 + * PY_SCIP_CALL(SCIPsetPresolving(self._scip, setting, True)) + * + * def setProbName(self, name): # <<<<<<<<<<<<<< + * """Set problem name""" + * n = str_conversion(name) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.setProbName", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1442 + * PY_SCIP_CALL(SCIPsetProbName(self._scip, n)) + * + * def setSeparating(self, setting): # <<<<<<<<<<<<<< + * """Set separating parameter settings. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_121setSeparating(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_120setSeparating, "Model.setSeparating(self, setting)\nSet separating parameter settings.\n\n :param setting: the parameter settings (SCIP_PARAMSETTING)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_121setSeparating = {"setSeparating", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_121setSeparating, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_120setSeparating}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_121setSeparating(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_setting = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setSeparating (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_setting,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_setting)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1442, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setSeparating") < 0)) __PYX_ERR(0, 1442, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_setting = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setSeparating", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1442, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setSeparating", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_120setSeparating(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_setting); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_120setSeparating(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_setting) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_PARAMSETTING __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setSeparating", 1); + + /* "src/pyscipopt/scip.pxi":1448 + * + * """ + * PY_SCIP_CALL(SCIPsetSeparating(self._scip, setting, True)) # <<<<<<<<<<<<<< + * + * def setHeuristics(self, setting): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_SCIP_PARAMSETTING(__pyx_v_setting); if (unlikely((__pyx_t_3 == ((SCIP_PARAMSETTING)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1448, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetSeparating(__pyx_v_self->_scip, __pyx_t_3, 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1442 + * PY_SCIP_CALL(SCIPsetProbName(self._scip, n)) + * + * def setSeparating(self, setting): # <<<<<<<<<<<<<< + * """Set separating parameter settings. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setSeparating", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1450 + * PY_SCIP_CALL(SCIPsetSeparating(self._scip, setting, True)) + * + * def setHeuristics(self, setting): # <<<<<<<<<<<<<< + * """Set heuristics parameter settings. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_123setHeuristics(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_122setHeuristics, "Model.setHeuristics(self, setting)\nSet heuristics parameter settings.\n\n :param setting: the parameter setting (SCIP_PARAMSETTING)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_123setHeuristics = {"setHeuristics", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_123setHeuristics, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_122setHeuristics}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_123setHeuristics(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_setting = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setHeuristics (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_setting,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_setting)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1450, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setHeuristics") < 0)) __PYX_ERR(0, 1450, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_setting = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setHeuristics", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1450, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setHeuristics", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_122setHeuristics(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_setting); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_122setHeuristics(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_setting) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_PARAMSETTING __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setHeuristics", 1); + + /* "src/pyscipopt/scip.pxi":1456 + * + * """ + * PY_SCIP_CALL(SCIPsetHeuristics(self._scip, setting, True)) # <<<<<<<<<<<<<< + * + * def disablePropagation(self, onlyroot=False): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_SCIP_PARAMSETTING(__pyx_v_setting); if (unlikely((__pyx_t_3 == ((SCIP_PARAMSETTING)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1456, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetHeuristics(__pyx_v_self->_scip, __pyx_t_3, 1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1450 + * PY_SCIP_CALL(SCIPsetSeparating(self._scip, setting, True)) + * + * def setHeuristics(self, setting): # <<<<<<<<<<<<<< + * """Set heuristics parameter settings. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setHeuristics", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1458 + * PY_SCIP_CALL(SCIPsetHeuristics(self._scip, setting, True)) + * + * def disablePropagation(self, onlyroot=False): # <<<<<<<<<<<<<< + * """Disables propagation in SCIP to avoid modifying the original problem during transformation. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_125disablePropagation(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_124disablePropagation, "Model.disablePropagation(self, onlyroot=False)\nDisables propagation in SCIP to avoid modifying the original problem during transformation.\n\n :param onlyroot: use propagation when root processing is finished (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_125disablePropagation = {"disablePropagation", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_125disablePropagation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_124disablePropagation}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_125disablePropagation(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_onlyroot = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("disablePropagation (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_onlyroot,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_onlyroot); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1458, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "disablePropagation") < 0)) __PYX_ERR(0, 1458, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_onlyroot = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("disablePropagation", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1458, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.disablePropagation", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_124disablePropagation(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_onlyroot); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_124disablePropagation(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_onlyroot) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("disablePropagation", 1); + + /* "src/pyscipopt/scip.pxi":1464 + * + * """ + * self.setIntParam("propagating/maxroundsroot", 0) # <<<<<<<<<<<<<< + * if not onlyroot: + * self.setIntParam("propagating/maxrounds", 0) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setIntParam); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1465 + * """ + * self.setIntParam("propagating/maxroundsroot", 0) + * if not onlyroot: # <<<<<<<<<<<<<< + * self.setIntParam("propagating/maxrounds", 0) + * + */ + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_onlyroot); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 1465, __pyx_L1_error) + __pyx_t_4 = (!__pyx_t_3); + if (__pyx_t_4) { + + /* "src/pyscipopt/scip.pxi":1466 + * self.setIntParam("propagating/maxroundsroot", 0) + * if not onlyroot: + * self.setIntParam("propagating/maxrounds", 0) # <<<<<<<<<<<<<< + * + * def writeProblem(self, filename='model.cip', trans=False, genericnames=False, verbose=True): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setIntParam); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__87, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1465 + * """ + * self.setIntParam("propagating/maxroundsroot", 0) + * if not onlyroot: # <<<<<<<<<<<<<< + * self.setIntParam("propagating/maxrounds", 0) + * + */ + } + + /* "src/pyscipopt/scip.pxi":1458 + * PY_SCIP_CALL(SCIPsetHeuristics(self._scip, setting, True)) + * + * def disablePropagation(self, onlyroot=False): # <<<<<<<<<<<<<< + * """Disables propagation in SCIP to avoid modifying the original problem during transformation. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.disablePropagation", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1468 + * self.setIntParam("propagating/maxrounds", 0) + * + * def writeProblem(self, filename='model.cip', trans=False, genericnames=False, verbose=True): # <<<<<<<<<<<<<< + * """Write current model/problem to a file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_127writeProblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_126writeProblem, "Model.writeProblem(self, filename=u'model.cip', trans=False, genericnames=False, verbose=True)\nWrite current model/problem to a file.\n\n :param filename: the name of the file to be used (Default value = 'model.cip'). Should have an extension corresponding to one of the readable file formats, described in https://www.scipopt.org/doc/html/group__FILEREADERS.php.\n :param trans: indicates whether the transformed problem is written to file (Default value = False)\n :param genericnames: indicates whether the problem should be written with generic variable and constraint names (Default value = False)\n :param verbose: indicates whether a success message should be printed\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_127writeProblem = {"writeProblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_127writeProblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_126writeProblem}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_127writeProblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_trans = 0; + PyObject *__pyx_v_genericnames = 0; + PyObject *__pyx_v_verbose = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeProblem (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_trans,&__pyx_n_s_genericnames,&__pyx_n_s_verbose,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_model_cip)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1468, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_trans); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1468, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_genericnames); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1468, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_verbose); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1468, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeProblem") < 0)) __PYX_ERR(0, 1468, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + __pyx_v_trans = values[1]; + __pyx_v_genericnames = values[2]; + __pyx_v_verbose = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeProblem", 0, 0, 4, __pyx_nargs); __PYX_ERR(0, 1468, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeProblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_126writeProblem(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename, __pyx_v_trans, __pyx_v_genericnames, __pyx_v_verbose); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_126writeProblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_trans, PyObject *__pyx_v_genericnames, PyObject *__pyx_v_verbose) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_str_absfile = NULL; + PyObject *__pyx_v_absfile = NULL; + PyObject *__pyx_v_fn = NULL; + PyObject *__pyx_v_ext = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + Py_ssize_t __pyx_t_7; + int __pyx_t_8; + char *__pyx_t_9; + char *__pyx_t_10; + SCIP_Bool __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeProblem", 1); + + /* "src/pyscipopt/scip.pxi":1476 + * :param verbose: indicates whether a success message should be printed + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 1476, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1477 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * str_absfile = abspath(filename) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1479 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * str_absfile = abspath(filename) # <<<<<<<<<<<<<< + * absfile = str_conversion(str_absfile) + * fn, ext = splitext(absfile) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_abspath); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_filename}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_str_absfile = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1480 + * + * str_absfile = abspath(filename) + * absfile = str_conversion(str_absfile) # <<<<<<<<<<<<<< + * fn, ext = splitext(absfile) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1480, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_str_absfile}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1480, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_absfile = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1481 + * str_absfile = abspath(filename) + * absfile = str_conversion(str_absfile) + * fn, ext = splitext(absfile) # <<<<<<<<<<<<<< + * + * if len(ext) == 0: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_splitext); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_absfile}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 1481, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + } else { + __pyx_t_2 = PyList_GET_ITEM(sequence, 0); + __pyx_t_3 = PyList_GET_ITEM(sequence, 1); + } + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_1 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); + index = 0; __pyx_t_2 = __pyx_t_6(__pyx_t_1); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_1); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_1), 2) < 0) __PYX_ERR(0, 1481, __pyx_L1_error) + __pyx_t_6 = NULL; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L4_unpacking_done; + __pyx_L3_unpacking_failed:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 1481, __pyx_L1_error) + __pyx_L4_unpacking_done:; + } + __pyx_v_fn = __pyx_t_2; + __pyx_t_2 = 0; + __pyx_v_ext = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1483 + * fn, ext = splitext(absfile) + * + * if len(ext) == 0: # <<<<<<<<<<<<<< + * ext = str_conversion('.cip') + * fn = fn + ext + */ + __pyx_t_7 = PyObject_Length(__pyx_v_ext); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 1483, __pyx_L1_error) + __pyx_t_8 = (__pyx_t_7 == 0); + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":1484 + * + * if len(ext) == 0: + * ext = str_conversion('.cip') # <<<<<<<<<<<<<< + * fn = fn + ext + * ext = ext[1:] + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_kp_u_cip}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF_SET(__pyx_v_ext, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1483 + * fn, ext = splitext(absfile) + * + * if len(ext) == 0: # <<<<<<<<<<<<<< + * ext = str_conversion('.cip') + * fn = fn + ext + */ + } + + /* "src/pyscipopt/scip.pxi":1485 + * if len(ext) == 0: + * ext = str_conversion('.cip') + * fn = fn + ext # <<<<<<<<<<<<<< + * ext = ext[1:] + * + */ + __pyx_t_4 = PyNumber_Add(__pyx_v_fn, __pyx_v_ext); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_fn, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1486 + * ext = str_conversion('.cip') + * fn = fn + ext + * ext = ext[1:] # <<<<<<<<<<<<<< + * + * if trans: + */ + __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_ext, 1, 0, NULL, NULL, &__pyx_slice__88, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_ext, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1488 + * ext = ext[1:] + * + * if trans: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPwriteTransProblem(self._scip, fn, ext, genericnames)) + * else: + */ + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_trans); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 1488, __pyx_L1_error) + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":1489 + * + * if trans: + * PY_SCIP_CALL(SCIPwriteTransProblem(self._scip, fn, ext, genericnames)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPwriteOrigProblem(self._scip, fn, ext, genericnames)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyObject_AsWritableString(__pyx_v_fn); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(0, 1489, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_AsWritableString(__pyx_v_ext); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 1489, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_genericnames); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1489, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPwriteTransProblem(__pyx_v_self->_scip, __pyx_t_9, __pyx_t_10, __pyx_t_11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_2}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1488 + * ext = ext[1:] + * + * if trans: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPwriteTransProblem(self._scip, fn, ext, genericnames)) + * else: + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/scip.pxi":1491 + * PY_SCIP_CALL(SCIPwriteTransProblem(self._scip, fn, ext, genericnames)) + * else: + * PY_SCIP_CALL(SCIPwriteOrigProblem(self._scip, fn, ext, genericnames)) # <<<<<<<<<<<<<< + * + * if verbose: + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_AsWritableString(__pyx_v_fn); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 1491, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_AsWritableString(__pyx_v_ext); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(0, 1491, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_genericnames); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1491, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPwriteOrigProblem(__pyx_v_self->_scip, __pyx_t_10, __pyx_t_9, __pyx_t_11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_2}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L6:; + + /* "src/pyscipopt/scip.pxi":1493 + * PY_SCIP_CALL(SCIPwriteOrigProblem(self._scip, fn, ext, genericnames)) + * + * if verbose: # <<<<<<<<<<<<<< + * print('wrote problem to file ' + str_absfile) + * + */ + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 1493, __pyx_L1_error) + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":1494 + * + * if verbose: + * print('wrote problem to file ' + str_absfile) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __pyx_t_4 = PyNumber_Add(__pyx_kp_u_wrote_problem_to_file, __pyx_v_str_absfile); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1493 + * PY_SCIP_CALL(SCIPwriteOrigProblem(self._scip, fn, ext, genericnames)) + * + * if verbose: # <<<<<<<<<<<<<< + * print('wrote problem to file ' + str_absfile) + * + */ + } + + /* "src/pyscipopt/scip.pxi":1496 + * print('wrote problem to file ' + str_absfile) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * # Variable Functions + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_locale); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_locale); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1468 + * self.setIntParam("propagating/maxrounds", 0) + * + * def writeProblem(self, filename='model.cip', trans=False, genericnames=False, verbose=True): # <<<<<<<<<<<<<< + * """Write current model/problem to a file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeProblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_str_absfile); + __Pyx_XDECREF(__pyx_v_absfile); + __Pyx_XDECREF(__pyx_v_fn); + __Pyx_XDECREF(__pyx_v_ext); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1500 + * # Variable Functions + * + * def addVar(self, name='', vtype='C', lb=0.0, ub=None, obj=0.0, pricedVar=False, pricedVarScore=1.0): # <<<<<<<<<<<<<< + * """Create a new variable. Default variable is non-negative and continuous. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_129addVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_128addVar, "Model.addVar(self, name=u'', vtype=u'C', lb=0.0, ub=None, obj=0.0, pricedVar=False, pricedVarScore=1.0)\nCreate a new variable. Default variable is non-negative and continuous.\n\n :param name: name of the variable, generic if empty (Default value = '')\n :param vtype: type of the variable: 'C' continuous, 'I' integer, 'B' binary, and 'M' implicit integer\n (see https://www.scipopt.org/doc/html/FAQ.php#implicitinteger) (Default value = 'C')\n :param lb: lower bound of the variable, use None for -infinity (Default value = 0.0)\n :param ub: upper bound of the variable, use None for +infinity (Default value = None)\n :param obj: objective value of variable (Default value = 0.0)\n :param pricedVar: is the variable a pricing candidate? (Default value = False)\n :param pricedVarScore: score of variable in case it is priced, the higher the better (Default value = 1.0)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_129addVar = {"addVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_129addVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_128addVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_129addVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_vtype = 0; + PyObject *__pyx_v_lb = 0; + PyObject *__pyx_v_ub = 0; + PyObject *__pyx_v_obj = 0; + PyObject *__pyx_v_pricedVar = 0; + PyObject *__pyx_v_pricedVarScore = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[7] = {0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_vtype,&__pyx_n_s_lb,&__pyx_n_s_ub,&__pyx_n_s_obj,&__pyx_n_s_pricedVar,&__pyx_n_s_pricedVarScore,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u__89)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_C)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_0_0)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_0_0)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_1_0)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1500, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vtype); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1500, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1500, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1500, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_obj); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1500, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pricedVar); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1500, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pricedVarScore); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1500, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addVar") < 0)) __PYX_ERR(0, 1500, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_name = values[0]; + __pyx_v_vtype = values[1]; + __pyx_v_lb = values[2]; + __pyx_v_ub = values[3]; + __pyx_v_obj = values[4]; + __pyx_v_pricedVar = values[5]; + __pyx_v_pricedVarScore = values[6]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addVar", 0, 0, 7, __pyx_nargs); __PYX_ERR(0, 1500, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_128addVar(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_vtype, __pyx_v_lb, __pyx_v_ub, __pyx_v_obj, __pyx_v_pricedVar, __pyx_v_pricedVarScore); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_128addVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_vtype, PyObject *__pyx_v_lb, PyObject *__pyx_v_ub, PyObject *__pyx_v_obj, PyObject *__pyx_v_pricedVar, PyObject *__pyx_v_pricedVarScore) { + SCIP_VAR *__pyx_v_scip_var; + PyObject *__pyx_v_cname = NULL; + PyObject *__pyx_v_pyVar = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + char *__pyx_t_7; + SCIP_Real __pyx_t_8; + SCIP_Real __pyx_t_9; + SCIP_Real __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addVar", 0); + __Pyx_INCREF(__pyx_v_name); + __Pyx_INCREF(__pyx_v_vtype); + __Pyx_INCREF(__pyx_v_lb); + __Pyx_INCREF(__pyx_v_ub); + + /* "src/pyscipopt/scip.pxi":1516 + * + * # replace empty name with generic one + * if name == '': # <<<<<<<<<<<<<< + * name = 'x'+str(SCIPgetNVars(self._scip)+1) + * cname = str_conversion(name) + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_kp_u__89, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1516, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1517 + * # replace empty name with generic one + * if name == '': + * name = 'x'+str(SCIPgetNVars(self._scip)+1) # <<<<<<<<<<<<<< + * cname = str_conversion(name) + * + */ + __pyx_t_2 = __Pyx_PyInt_From_long((SCIPgetNVars(__pyx_v_self->_scip) + 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Str(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_n_u_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1516 + * + * # replace empty name with generic one + * if name == '': # <<<<<<<<<<<<<< + * name = 'x'+str(SCIPgetNVars(self._scip)+1) + * cname = str_conversion(name) + */ + } + + /* "src/pyscipopt/scip.pxi":1518 + * if name == '': + * name = 'x'+str(SCIPgetNVars(self._scip)+1) + * cname = str_conversion(name) # <<<<<<<<<<<<<< + * + * # replace None with corresponding infinity + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_cname = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1521 + * + * # replace None with corresponding infinity + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * if ub is None: + */ + __pyx_t_1 = (__pyx_v_lb == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1522 + * # replace None with corresponding infinity + * if lb is None: + * lb = -SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * if ub is None: + * ub = SCIPinfinity(self._scip) + */ + __pyx_t_2 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_lb, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1521 + * + * # replace None with corresponding infinity + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * if ub is None: + */ + } + + /* "src/pyscipopt/scip.pxi":1523 + * if lb is None: + * lb = -SCIPinfinity(self._scip) + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * + */ + __pyx_t_1 = (__pyx_v_ub == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1524 + * lb = -SCIPinfinity(self._scip) + * if ub is None: + * ub = SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * + * vtype = vtype.upper() + */ + __pyx_t_2 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_ub, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1523 + * if lb is None: + * lb = -SCIPinfinity(self._scip) + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * + */ + } + + /* "src/pyscipopt/scip.pxi":1526 + * ub = SCIPinfinity(self._scip) + * + * vtype = vtype.upper() # <<<<<<<<<<<<<< + * if vtype in ['C', 'CONTINUOUS']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS)) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_vtype, __pyx_n_s_upper); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF_SET(__pyx_v_vtype, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1527 + * + * vtype = vtype.upper() + * if vtype in ['C', 'CONTINUOUS']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS)) + * elif vtype in ['B', 'BINARY']: + */ + __Pyx_INCREF(__pyx_v_vtype); + __pyx_t_2 = __pyx_v_vtype; + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_C, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 1527, __pyx_L1_error) + if (!__pyx_t_6) { + } else { + __pyx_t_1 = __pyx_t_6; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_CONTINUOUS, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 1527, __pyx_L1_error) + __pyx_t_1 = __pyx_t_6; + __pyx_L7_bool_binop_done:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __pyx_t_1; + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":1528 + * vtype = vtype.upper() + * if vtype in ['C', 'CONTINUOUS']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS)) # <<<<<<<<<<<<<< + * elif vtype in ['B', 'BINARY']: + * if ub > 1.0: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_cname); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 1528, __pyx_L1_error) + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1528, __pyx_L1_error) + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1528, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_obj); if (unlikely((__pyx_t_10 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1528, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateVarBasic(__pyx_v_self->_scip, (&__pyx_v_scip_var), __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, SCIP_VARTYPE_CONTINUOUS)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1527 + * + * vtype = vtype.upper() + * if vtype in ['C', 'CONTINUOUS']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS)) + * elif vtype in ['B', 'BINARY']: + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/scip.pxi":1529 + * if vtype in ['C', 'CONTINUOUS']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS)) + * elif vtype in ['B', 'BINARY']: # <<<<<<<<<<<<<< + * if ub > 1.0: + * ub = 1.0 + */ + __Pyx_INCREF(__pyx_v_vtype); + __pyx_t_2 = __pyx_v_vtype; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_B, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1529, __pyx_L1_error) + if (!__pyx_t_1) { + } else { + __pyx_t_6 = __pyx_t_1; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_BINARY, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1529, __pyx_L1_error) + __pyx_t_6 = __pyx_t_1; + __pyx_L9_bool_binop_done:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_6; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1530 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS)) + * elif vtype in ['B', 'BINARY']: + * if ub > 1.0: # <<<<<<<<<<<<<< + * ub = 1.0 + * if lb < 0.0: + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_ub, __pyx_float_1_0, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1530, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1530, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1531 + * elif vtype in ['B', 'BINARY']: + * if ub > 1.0: + * ub = 1.0 # <<<<<<<<<<<<<< + * if lb < 0.0: + * lb = 0.0 + */ + __Pyx_INCREF(__pyx_float_1_0); + __Pyx_DECREF_SET(__pyx_v_ub, __pyx_float_1_0); + + /* "src/pyscipopt/scip.pxi":1530 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS)) + * elif vtype in ['B', 'BINARY']: + * if ub > 1.0: # <<<<<<<<<<<<<< + * ub = 1.0 + * if lb < 0.0: + */ + } + + /* "src/pyscipopt/scip.pxi":1532 + * if ub > 1.0: + * ub = 1.0 + * if lb < 0.0: # <<<<<<<<<<<<<< + * lb = 0.0 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_BINARY)) + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_lb, __pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1532, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1532, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1533 + * ub = 1.0 + * if lb < 0.0: + * lb = 0.0 # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_BINARY)) + * elif vtype in ['I', 'INTEGER']: + */ + __Pyx_INCREF(__pyx_float_0_0); + __Pyx_DECREF_SET(__pyx_v_lb, __pyx_float_0_0); + + /* "src/pyscipopt/scip.pxi":1532 + * if ub > 1.0: + * ub = 1.0 + * if lb < 0.0: # <<<<<<<<<<<<<< + * lb = 0.0 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_BINARY)) + */ + } + + /* "src/pyscipopt/scip.pxi":1534 + * if lb < 0.0: + * lb = 0.0 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_BINARY)) # <<<<<<<<<<<<<< + * elif vtype in ['I', 'INTEGER']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_cname); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 1534, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_10 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1534, __pyx_L1_error) + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1534, __pyx_L1_error) + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_obj); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1534, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateVarBasic(__pyx_v_self->_scip, (&__pyx_v_scip_var), __pyx_t_7, __pyx_t_10, __pyx_t_9, __pyx_t_8, SCIP_VARTYPE_BINARY)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1529 + * if vtype in ['C', 'CONTINUOUS']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS)) + * elif vtype in ['B', 'BINARY']: # <<<<<<<<<<<<<< + * if ub > 1.0: + * ub = 1.0 + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/scip.pxi":1535 + * lb = 0.0 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_BINARY)) + * elif vtype in ['I', 'INTEGER']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER)) + * elif vtype in ['M', 'IMPLINT']: + */ + __Pyx_INCREF(__pyx_v_vtype); + __pyx_t_2 = __pyx_v_vtype; + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_I, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 1535, __pyx_L1_error) + if (!__pyx_t_6) { + } else { + __pyx_t_1 = __pyx_t_6; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_INTEGER, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 1535, __pyx_L1_error) + __pyx_t_1 = __pyx_t_6; + __pyx_L13_bool_binop_done:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __pyx_t_1; + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":1536 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_BINARY)) + * elif vtype in ['I', 'INTEGER']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER)) # <<<<<<<<<<<<<< + * elif vtype in ['M', 'IMPLINT']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_IMPLINT)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_cname); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 1536, __pyx_L1_error) + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1536, __pyx_L1_error) + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1536, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_obj); if (unlikely((__pyx_t_10 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1536, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateVarBasic(__pyx_v_self->_scip, (&__pyx_v_scip_var), __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, SCIP_VARTYPE_INTEGER)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1535 + * lb = 0.0 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_BINARY)) + * elif vtype in ['I', 'INTEGER']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER)) + * elif vtype in ['M', 'IMPLINT']: + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/scip.pxi":1537 + * elif vtype in ['I', 'INTEGER']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER)) + * elif vtype in ['M', 'IMPLINT']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_IMPLINT)) + * else: + */ + __Pyx_INCREF(__pyx_v_vtype); + __pyx_t_2 = __pyx_v_vtype; + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_M, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1537, __pyx_L1_error) + if (!__pyx_t_1) { + } else { + __pyx_t_6 = __pyx_t_1; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_IMPLINT, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1537, __pyx_L1_error) + __pyx_t_6 = __pyx_t_1; + __pyx_L15_bool_binop_done:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_6; + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":1538 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER)) + * elif vtype in ['M', 'IMPLINT']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_IMPLINT)) # <<<<<<<<<<<<<< + * else: + * raise Warning("unrecognized variable type") + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_cname); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 1538, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_10 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1538, __pyx_L1_error) + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1538, __pyx_L1_error) + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_obj); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1538, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateVarBasic(__pyx_v_self->_scip, (&__pyx_v_scip_var), __pyx_t_7, __pyx_t_10, __pyx_t_9, __pyx_t_8, SCIP_VARTYPE_IMPLINT)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1537 + * elif vtype in ['I', 'INTEGER']: + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER)) + * elif vtype in ['M', 'IMPLINT']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_IMPLINT)) + * else: + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/scip.pxi":1540 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_IMPLINT)) + * else: + * raise Warning("unrecognized variable type") # <<<<<<<<<<<<<< + * + * if pricedVar: + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 1540, __pyx_L1_error) + } + __pyx_L6:; + + /* "src/pyscipopt/scip.pxi":1542 + * raise Warning("unrecognized variable type") + * + * if pricedVar: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddPricedVar(self._scip, scip_var, pricedVarScore)) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_pricedVar); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1542, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1543 + * + * if pricedVar: + * PY_SCIP_CALL(SCIPaddPricedVar(self._scip, scip_var, pricedVarScore)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPaddVar(self._scip, scip_var)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_pricedVarScore); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1543, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddPricedVar(__pyx_v_self->_scip, __pyx_v_scip_var, __pyx_t_8)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1542 + * raise Warning("unrecognized variable type") + * + * if pricedVar: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddPricedVar(self._scip, scip_var, pricedVarScore)) + * else: + */ + goto __pyx_L17; + } + + /* "src/pyscipopt/scip.pxi":1545 + * PY_SCIP_CALL(SCIPaddPricedVar(self._scip, scip_var, pricedVarScore)) + * else: + * PY_SCIP_CALL(SCIPaddVar(self._scip, scip_var)) # <<<<<<<<<<<<<< + * + * pyVar = Variable.create(scip_var) + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVar(__pyx_v_self->_scip, __pyx_v_scip_var)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L17:; + + /* "src/pyscipopt/scip.pxi":1547 + * PY_SCIP_CALL(SCIPaddVar(self._scip, scip_var)) + * + * pyVar = Variable.create(scip_var) # <<<<<<<<<<<<<< + * + * # store variable in the model to avoid creating new python variable objects in getVars() + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v_scip_var); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_pyVar = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1550 + * + * # store variable in the model to avoid creating new python variable objects in getVars() + * assert not pyVar.ptr() in self._modelvars # <<<<<<<<<<<<<< + * self._modelvars[pyVar.ptr()] = pyVar + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_pyVar, __pyx_n_s_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_2, __pyx_v_self->_modelvars, Py_NE)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1550, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 1550, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 1550, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":1551 + * # store variable in the model to avoid creating new python variable objects in getVars() + * assert not pyVar.ptr() in self._modelvars + * self._modelvars[pyVar.ptr()] = pyVar # <<<<<<<<<<<<<< + * + * #setting the variable data + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_pyVar, __pyx_n_s_ptr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + if (unlikely((PyObject_SetItem(__pyx_v_self->_modelvars, __pyx_t_2, __pyx_v_pyVar) < 0))) __PYX_ERR(0, 1551, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1554 + * + * #setting the variable data + * SCIPvarSetData(scip_var, pyVar) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseVar(self._scip, &scip_var)) + * return pyVar + */ + SCIPvarSetData(__pyx_v_scip_var, ((SCIP_VARDATA *)__pyx_v_pyVar)); + + /* "src/pyscipopt/scip.pxi":1555 + * #setting the variable data + * SCIPvarSetData(scip_var, pyVar) + * PY_SCIP_CALL(SCIPreleaseVar(self._scip, &scip_var)) # <<<<<<<<<<<<<< + * return pyVar + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseVar(__pyx_v_self->_scip, (&__pyx_v_scip_var))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1556 + * SCIPvarSetData(scip_var, pyVar) + * PY_SCIP_CALL(SCIPreleaseVar(self._scip, &scip_var)) + * return pyVar # <<<<<<<<<<<<<< + * + * def getTransformedVar(self, Variable var): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyVar); + __pyx_r = __pyx_v_pyVar; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1500 + * # Variable Functions + * + * def addVar(self, name='', vtype='C', lb=0.0, ub=None, obj=0.0, pricedVar=False, pricedVarScore=1.0): # <<<<<<<<<<<<<< + * """Create a new variable. Default variable is non-negative and continuous. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("pyscipopt.scip.Model.addVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_cname); + __Pyx_XDECREF(__pyx_v_pyVar); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_vtype); + __Pyx_XDECREF(__pyx_v_lb); + __Pyx_XDECREF(__pyx_v_ub); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1558 + * return pyVar + * + * def getTransformedVar(self, Variable var): # <<<<<<<<<<<<<< + * """Retrieve the transformed variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_131getTransformedVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_130getTransformedVar, "Model.getTransformedVar(self, Variable var)\nRetrieve the transformed variable.\n\n :param Variable var: original variable to get the transformed of\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_131getTransformedVar = {"getTransformedVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_131getTransformedVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_130getTransformedVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_131getTransformedVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getTransformedVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1558, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getTransformedVar") < 0)) __PYX_ERR(0, 1558, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getTransformedVar", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1558, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getTransformedVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1558, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_130getTransformedVar(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_130getTransformedVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + SCIP_VAR *__pyx_v__tvar; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getTransformedVar", 1); + + /* "src/pyscipopt/scip.pxi":1565 + * """ + * cdef SCIP_VAR* _tvar + * PY_SCIP_CALL(SCIPgetTransformedVar(self._scip, var.scip_var, &_tvar)) # <<<<<<<<<<<<<< + * + * return Variable.create(_tvar) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetTransformedVar(__pyx_v_self->_scip, __pyx_v_var->scip_var, (&__pyx_v__tvar))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1567 + * PY_SCIP_CALL(SCIPgetTransformedVar(self._scip, var.scip_var, &_tvar)) + * + * return Variable.create(_tvar) # <<<<<<<<<<<<<< + * + * def addVarLocks(self, Variable var, nlocksdown, nlocksup): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v__tvar); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1558 + * return pyVar + * + * def getTransformedVar(self, Variable var): # <<<<<<<<<<<<<< + * """Retrieve the transformed variable. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getTransformedVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1569 + * return Variable.create(_tvar) + * + * def addVarLocks(self, Variable var, nlocksdown, nlocksup): # <<<<<<<<<<<<<< + * """adds given values to lock numbers of variable for rounding + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_133addVarLocks(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_132addVarLocks, "Model.addVarLocks(self, Variable var, nlocksdown, nlocksup)\nadds given values to lock numbers of variable for rounding\n\n :param Variable var: variable to adjust the locks for\n :param nlocksdown: new number of down locks\n :param nlocksup: new number of up locks\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_133addVarLocks = {"addVarLocks", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_133addVarLocks, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_132addVarLocks}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_133addVarLocks(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_nlocksdown = 0; + PyObject *__pyx_v_nlocksup = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addVarLocks (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_nlocksdown,&__pyx_n_s_nlocksup,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1569, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nlocksdown)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1569, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addVarLocks", 1, 3, 3, 1); __PYX_ERR(0, 1569, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nlocksup)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1569, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addVarLocks", 1, 3, 3, 2); __PYX_ERR(0, 1569, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addVarLocks") < 0)) __PYX_ERR(0, 1569, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_nlocksdown = values[1]; + __pyx_v_nlocksup = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addVarLocks", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1569, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addVarLocks", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1569, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_132addVarLocks(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_nlocksdown, __pyx_v_nlocksup); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_132addVarLocks(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_nlocksdown, PyObject *__pyx_v_nlocksup) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addVarLocks", 1); + + /* "src/pyscipopt/scip.pxi":1577 + * + * """ + * PY_SCIP_CALL(SCIPaddVarLocks(self._scip, var.scip_var, nlocksdown, nlocksup)) # <<<<<<<<<<<<<< + * + * def fixVar(self, Variable var, val): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_nlocksdown); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1577, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_nlocksup); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1577, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVarLocks(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1569 + * return Variable.create(_tvar) + * + * def addVarLocks(self, Variable var, nlocksdown, nlocksup): # <<<<<<<<<<<<<< + * """adds given values to lock numbers of variable for rounding + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.addVarLocks", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1579 + * PY_SCIP_CALL(SCIPaddVarLocks(self._scip, var.scip_var, nlocksdown, nlocksup)) + * + * def fixVar(self, Variable var, val): # <<<<<<<<<<<<<< + * """Fixes the variable var to the value val if possible. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_135fixVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_134fixVar, "Model.fixVar(self, Variable var, val)\nFixes the variable var to the value val if possible.\n\n :param Variable var: variable to fix\n :param val: float, the fix value\n :return: tuple (infeasible, fixed) of booleans\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_135fixVar = {"fixVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_135fixVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_134fixVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_135fixVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_val = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("fixVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_val,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1579, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("fixVar", 1, 2, 2, 1); __PYX_ERR(0, 1579, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "fixVar") < 0)) __PYX_ERR(0, 1579, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_val = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("fixVar", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1579, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.fixVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1579, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_134fixVar(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_val); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_134fixVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_val) { + SCIP_Bool __pyx_v_infeasible; + SCIP_Bool __pyx_v_fixed; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fixVar", 1); + + /* "src/pyscipopt/scip.pxi":1589 + * cdef SCIP_Bool infeasible + * cdef SCIP_Bool fixed + * PY_SCIP_CALL(SCIPfixVar(self._scip, var.scip_var, val, &infeasible, &fixed)) # <<<<<<<<<<<<<< + * return infeasible, fixed + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_val); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1589, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPfixVar(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3, (&__pyx_v_infeasible), (&__pyx_v_fixed))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1590 + * cdef SCIP_Bool fixed + * PY_SCIP_CALL(SCIPfixVar(self._scip, var.scip_var, val, &infeasible, &fixed)) + * return infeasible, fixed # <<<<<<<<<<<<<< + * + * def delVar(self, Variable var): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_infeasible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_fixed); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 1590, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(0, 1590, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1579 + * PY_SCIP_CALL(SCIPaddVarLocks(self._scip, var.scip_var, nlocksdown, nlocksup)) + * + * def fixVar(self, Variable var, val): # <<<<<<<<<<<<<< + * """Fixes the variable var to the value val if possible. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.fixVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1592 + * return infeasible, fixed + * + * def delVar(self, Variable var): # <<<<<<<<<<<<<< + * """Delete a variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_137delVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_136delVar, "Model.delVar(self, Variable var)\nDelete a variable.\n\n :param var: the variable which shall be deleted\n :return: bool, was deleting succesful\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_137delVar = {"delVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_137delVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_136delVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_137delVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("delVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1592, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delVar") < 0)) __PYX_ERR(0, 1592, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delVar", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1592, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.delVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1592, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_136delVar(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_136delVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + SCIP_Bool __pyx_v_deleted; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("delVar", 1); + + /* "src/pyscipopt/scip.pxi":1600 + * """ + * cdef SCIP_Bool deleted + * if var.ptr() in self._modelvars: # <<<<<<<<<<<<<< + * del self._modelvars[var.ptr()] + * PY_SCIP_CALL(SCIPdelVar(self._scip, var.scip_var, &deleted)) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_var), __pyx_n_s_ptr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_v_self->_modelvars, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 1600, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":1601 + * cdef SCIP_Bool deleted + * if var.ptr() in self._modelvars: + * del self._modelvars[var.ptr()] # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPdelVar(self._scip, var.scip_var, &deleted)) + * return deleted + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_var), __pyx_n_s_ptr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + if (unlikely((PyObject_DelItem(__pyx_v_self->_modelvars, __pyx_t_1) < 0))) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1600 + * """ + * cdef SCIP_Bool deleted + * if var.ptr() in self._modelvars: # <<<<<<<<<<<<<< + * del self._modelvars[var.ptr()] + * PY_SCIP_CALL(SCIPdelVar(self._scip, var.scip_var, &deleted)) + */ + } + + /* "src/pyscipopt/scip.pxi":1602 + * if var.ptr() in self._modelvars: + * del self._modelvars[var.ptr()] + * PY_SCIP_CALL(SCIPdelVar(self._scip, var.scip_var, &deleted)) # <<<<<<<<<<<<<< + * return deleted + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPdelVar(__pyx_v_self->_scip, __pyx_v_var->scip_var, (&__pyx_v_deleted))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1603 + * del self._modelvars[var.ptr()] + * PY_SCIP_CALL(SCIPdelVar(self._scip, var.scip_var, &deleted)) + * return deleted # <<<<<<<<<<<<<< + * + * def tightenVarLb(self, Variable var, lb, force=False): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_deleted); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1603, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1592 + * return infeasible, fixed + * + * def delVar(self, Variable var): # <<<<<<<<<<<<<< + * """Delete a variable. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.delVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1605 + * return deleted + * + * def tightenVarLb(self, Variable var, lb, force=False): # <<<<<<<<<<<<<< + * """Tighten the lower bound in preprocessing or current node, if the bound is tighter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_139tightenVarLb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_138tightenVarLb, "Model.tightenVarLb(self, Variable var, lb, force=False)\nTighten the lower bound in preprocessing or current node, if the bound is tighter.\n\n :param var: SCIP variable\n :param lb: possible new lower bound\n :param force: force tightening even if below bound strengthening tolerance\n :return: tuple of bools, (infeasible, tightened)\n infeasible: whether new domain is empty\n tightened: whether the bound was tightened\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_139tightenVarLb = {"tightenVarLb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_139tightenVarLb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_138tightenVarLb}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_139tightenVarLb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_lb = 0; + PyObject *__pyx_v_force = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("tightenVarLb (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_lb,&__pyx_n_s_force,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1605, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1605, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("tightenVarLb", 0, 2, 3, 1); __PYX_ERR(0, 1605, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_force); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1605, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "tightenVarLb") < 0)) __PYX_ERR(0, 1605, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_lb = values[1]; + __pyx_v_force = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("tightenVarLb", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 1605, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.tightenVarLb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1605, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_138tightenVarLb(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_lb, __pyx_v_force); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_138tightenVarLb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb, PyObject *__pyx_v_force) { + SCIP_Bool __pyx_v_infeasible; + SCIP_Bool __pyx_v_tightened; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + SCIP_Bool __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("tightenVarLb", 1); + + /* "src/pyscipopt/scip.pxi":1618 + * cdef SCIP_Bool infeasible + * cdef SCIP_Bool tightened + * PY_SCIP_CALL(SCIPtightenVarLb(self._scip, var.scip_var, lb, force, &infeasible, &tightened)) # <<<<<<<<<<<<<< + * return infeasible, tightened + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1618, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_force); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1618, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPtightenVarLb(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3, __pyx_t_4, (&__pyx_v_infeasible), (&__pyx_v_tightened))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1619 + * cdef SCIP_Bool tightened + * PY_SCIP_CALL(SCIPtightenVarLb(self._scip, var.scip_var, lb, force, &infeasible, &tightened)) + * return infeasible, tightened # <<<<<<<<<<<<<< + * + * def tightenVarUb(self, Variable var, ub, force=False): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_infeasible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_tightened); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(0, 1619, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2)) __PYX_ERR(0, 1619, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1605 + * return deleted + * + * def tightenVarLb(self, Variable var, lb, force=False): # <<<<<<<<<<<<<< + * """Tighten the lower bound in preprocessing or current node, if the bound is tighter. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.tightenVarLb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1621 + * return infeasible, tightened + * + * def tightenVarUb(self, Variable var, ub, force=False): # <<<<<<<<<<<<<< + * """Tighten the upper bound in preprocessing or current node, if the bound is tighter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_141tightenVarUb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_140tightenVarUb, "Model.tightenVarUb(self, Variable var, ub, force=False)\nTighten the upper bound in preprocessing or current node, if the bound is tighter.\n\n :param var: SCIP variable\n :param ub: possible new upper bound\n :param force: force tightening even if below bound strengthening tolerance\n :return: tuple of bools, (infeasible, tightened)\n infeasible: whether new domain is empty\n tightened: whether the bound was tightened\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_141tightenVarUb = {"tightenVarUb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_141tightenVarUb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_140tightenVarUb}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_141tightenVarUb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_ub = 0; + PyObject *__pyx_v_force = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("tightenVarUb (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_ub,&__pyx_n_s_force,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1621, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1621, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("tightenVarUb", 0, 2, 3, 1); __PYX_ERR(0, 1621, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_force); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1621, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "tightenVarUb") < 0)) __PYX_ERR(0, 1621, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_ub = values[1]; + __pyx_v_force = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("tightenVarUb", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 1621, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.tightenVarUb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1621, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_140tightenVarUb(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_ub, __pyx_v_force); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_140tightenVarUb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub, PyObject *__pyx_v_force) { + SCIP_Bool __pyx_v_infeasible; + SCIP_Bool __pyx_v_tightened; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + SCIP_Bool __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("tightenVarUb", 1); + + /* "src/pyscipopt/scip.pxi":1634 + * cdef SCIP_Bool infeasible + * cdef SCIP_Bool tightened + * PY_SCIP_CALL(SCIPtightenVarUb(self._scip, var.scip_var, ub, force, &infeasible, &tightened)) # <<<<<<<<<<<<<< + * return infeasible, tightened + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1634, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_force); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1634, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPtightenVarUb(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3, __pyx_t_4, (&__pyx_v_infeasible), (&__pyx_v_tightened))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1635 + * cdef SCIP_Bool tightened + * PY_SCIP_CALL(SCIPtightenVarUb(self._scip, var.scip_var, ub, force, &infeasible, &tightened)) + * return infeasible, tightened # <<<<<<<<<<<<<< + * + * def tightenVarUbGlobal(self, Variable var, ub, force=False): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_infeasible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_tightened); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(0, 1635, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2)) __PYX_ERR(0, 1635, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1621 + * return infeasible, tightened + * + * def tightenVarUb(self, Variable var, ub, force=False): # <<<<<<<<<<<<<< + * """Tighten the upper bound in preprocessing or current node, if the bound is tighter. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.tightenVarUb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1637 + * return infeasible, tightened + * + * def tightenVarUbGlobal(self, Variable var, ub, force=False): # <<<<<<<<<<<<<< + * """Tighten the global upper bound, if the bound is tighter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_143tightenVarUbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_142tightenVarUbGlobal, "Model.tightenVarUbGlobal(self, Variable var, ub, force=False)\nTighten the global upper bound, if the bound is tighter.\n\n :param var: SCIP variable\n :param ub: possible new upper bound\n :param force: force tightening even if below bound strengthening tolerance\n :return: tuple of bools, (infeasible, tightened)\n infeasible: whether new domain is empty\n tightened: whether the bound was tightened\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_143tightenVarUbGlobal = {"tightenVarUbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_143tightenVarUbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_142tightenVarUbGlobal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_143tightenVarUbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_ub = 0; + PyObject *__pyx_v_force = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("tightenVarUbGlobal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_ub,&__pyx_n_s_force,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1637, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1637, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("tightenVarUbGlobal", 0, 2, 3, 1); __PYX_ERR(0, 1637, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_force); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1637, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "tightenVarUbGlobal") < 0)) __PYX_ERR(0, 1637, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_ub = values[1]; + __pyx_v_force = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("tightenVarUbGlobal", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 1637, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.tightenVarUbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1637, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_142tightenVarUbGlobal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_ub, __pyx_v_force); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_142tightenVarUbGlobal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub, PyObject *__pyx_v_force) { + SCIP_Bool __pyx_v_infeasible; + SCIP_Bool __pyx_v_tightened; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + SCIP_Bool __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("tightenVarUbGlobal", 1); + + /* "src/pyscipopt/scip.pxi":1650 + * cdef SCIP_Bool infeasible + * cdef SCIP_Bool tightened + * PY_SCIP_CALL(SCIPtightenVarUbGlobal(self._scip, var.scip_var, ub, force, &infeasible, &tightened)) # <<<<<<<<<<<<<< + * return infeasible, tightened + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1650, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1650, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_force); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1650, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPtightenVarUbGlobal(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3, __pyx_t_4, (&__pyx_v_infeasible), (&__pyx_v_tightened))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1650, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1650, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1651 + * cdef SCIP_Bool tightened + * PY_SCIP_CALL(SCIPtightenVarUbGlobal(self._scip, var.scip_var, ub, force, &infeasible, &tightened)) + * return infeasible, tightened # <<<<<<<<<<<<<< + * + * def tightenVarLbGlobal(self, Variable var, lb, force=False): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_infeasible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_tightened); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(0, 1651, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2)) __PYX_ERR(0, 1651, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1637 + * return infeasible, tightened + * + * def tightenVarUbGlobal(self, Variable var, ub, force=False): # <<<<<<<<<<<<<< + * """Tighten the global upper bound, if the bound is tighter. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.tightenVarUbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1653 + * return infeasible, tightened + * + * def tightenVarLbGlobal(self, Variable var, lb, force=False): # <<<<<<<<<<<<<< + * """Tighten the global upper bound, if the bound is tighter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_145tightenVarLbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_144tightenVarLbGlobal, "Model.tightenVarLbGlobal(self, Variable var, lb, force=False)\nTighten the global upper bound, if the bound is tighter.\n\n :param var: SCIP variable\n :param lb: possible new upper bound\n :param force: force tightening even if below bound strengthening tolerance\n :return: tuple of bools, (infeasible, tightened)\n infeasible: whether new domain is empty\n tightened: whether the bound was tightened\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_145tightenVarLbGlobal = {"tightenVarLbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_145tightenVarLbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_144tightenVarLbGlobal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_145tightenVarLbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_lb = 0; + PyObject *__pyx_v_force = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("tightenVarLbGlobal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_lb,&__pyx_n_s_force,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1653, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1653, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("tightenVarLbGlobal", 0, 2, 3, 1); __PYX_ERR(0, 1653, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_force); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1653, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "tightenVarLbGlobal") < 0)) __PYX_ERR(0, 1653, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_lb = values[1]; + __pyx_v_force = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("tightenVarLbGlobal", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 1653, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.tightenVarLbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1653, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_144tightenVarLbGlobal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_lb, __pyx_v_force); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_144tightenVarLbGlobal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb, PyObject *__pyx_v_force) { + SCIP_Bool __pyx_v_infeasible; + SCIP_Bool __pyx_v_tightened; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + SCIP_Bool __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("tightenVarLbGlobal", 1); + + /* "src/pyscipopt/scip.pxi":1666 + * cdef SCIP_Bool infeasible + * cdef SCIP_Bool tightened + * PY_SCIP_CALL(SCIPtightenVarLbGlobal(self._scip, var.scip_var, lb, force, &infeasible, &tightened)) # <<<<<<<<<<<<<< + * return infeasible, tightened + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1666, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_force); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1666, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPtightenVarLbGlobal(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3, __pyx_t_4, (&__pyx_v_infeasible), (&__pyx_v_tightened))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1667 + * cdef SCIP_Bool tightened + * PY_SCIP_CALL(SCIPtightenVarLbGlobal(self._scip, var.scip_var, lb, force, &infeasible, &tightened)) + * return infeasible, tightened # <<<<<<<<<<<<<< + * + * def chgVarLb(self, Variable var, lb): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_infeasible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_tightened); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(0, 1667, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2)) __PYX_ERR(0, 1667, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1653 + * return infeasible, tightened + * + * def tightenVarLbGlobal(self, Variable var, lb, force=False): # <<<<<<<<<<<<<< + * """Tighten the global upper bound, if the bound is tighter. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.tightenVarLbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1669 + * return infeasible, tightened + * + * def chgVarLb(self, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the lower bound of the specified variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_147chgVarLb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_146chgVarLb, "Model.chgVarLb(self, Variable var, lb)\nChanges the lower bound of the specified variable.\n\n :param Variable var: variable to change bound of\n :param lb: new lower bound (set to None for -infinity)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_147chgVarLb = {"chgVarLb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_147chgVarLb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_146chgVarLb}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_147chgVarLb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_lb = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarLb (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_lb,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1669, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1669, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarLb", 1, 2, 2, 1); __PYX_ERR(0, 1669, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarLb") < 0)) __PYX_ERR(0, 1669, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_lb = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarLb", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1669, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1669, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_146chgVarLb(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_lb); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_146chgVarLb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarLb", 0); + __Pyx_INCREF(__pyx_v_lb); + + /* "src/pyscipopt/scip.pxi":1676 + * + * """ + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb)) + */ + __pyx_t_1 = (__pyx_v_lb == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1677 + * """ + * if lb is None: + * lb = -SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb)) + * + */ + __pyx_t_2 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_lb, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1676 + * + * """ + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb)) + */ + } + + /* "src/pyscipopt/scip.pxi":1678 + * if lb is None: + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb)) # <<<<<<<<<<<<<< + * + * def chgVarUb(self, Variable var, ub): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1678, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarLb(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1669 + * return infeasible, tightened + * + * def chgVarLb(self, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the lower bound of the specified variable. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lb); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1680 + * PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb)) + * + * def chgVarUb(self, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the upper bound of the specified variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_149chgVarUb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_148chgVarUb, "Model.chgVarUb(self, Variable var, ub)\nChanges the upper bound of the specified variable.\n\n :param Variable var: variable to change bound of\n :param ub: new upper bound (set to None for +infinity)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_149chgVarUb = {"chgVarUb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_149chgVarUb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_148chgVarUb}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_149chgVarUb(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_ub = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarUb (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_ub,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1680, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1680, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarUb", 1, 2, 2, 1); __PYX_ERR(0, 1680, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarUb") < 0)) __PYX_ERR(0, 1680, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_ub = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarUb", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1680, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1680, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_148chgVarUb(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_ub); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_148chgVarUb(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarUb", 0); + __Pyx_INCREF(__pyx_v_ub); + + /* "src/pyscipopt/scip.pxi":1687 + * + * """ + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub)) + */ + __pyx_t_1 = (__pyx_v_ub == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1688 + * """ + * if ub is None: + * ub = SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub)) + * + */ + __pyx_t_2 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_ub, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1687 + * + * """ + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub)) + */ + } + + /* "src/pyscipopt/scip.pxi":1689 + * if ub is None: + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub)) # <<<<<<<<<<<<<< + * + * def chgVarLbGlobal(self, Variable var, lb): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1689, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarUb(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1680 + * PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb)) + * + * def chgVarUb(self, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the upper bound of the specified variable. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUb", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ub); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1691 + * PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub)) + * + * def chgVarLbGlobal(self, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the global lower bound of the specified variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_151chgVarLbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_150chgVarLbGlobal, "Model.chgVarLbGlobal(self, Variable var, lb)\nChanges the global lower bound of the specified variable.\n\n :param Variable var: variable to change bound of\n :param lb: new lower bound (set to None for -infinity)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_151chgVarLbGlobal = {"chgVarLbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_151chgVarLbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_150chgVarLbGlobal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_151chgVarLbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_lb = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarLbGlobal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_lb,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1691, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1691, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarLbGlobal", 1, 2, 2, 1); __PYX_ERR(0, 1691, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarLbGlobal") < 0)) __PYX_ERR(0, 1691, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_lb = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarLbGlobal", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1691, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1691, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_150chgVarLbGlobal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_lb); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_150chgVarLbGlobal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarLbGlobal", 0); + __Pyx_INCREF(__pyx_v_lb); + + /* "src/pyscipopt/scip.pxi":1698 + * + * """ + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb)) + */ + __pyx_t_1 = (__pyx_v_lb == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1699 + * """ + * if lb is None: + * lb = -SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb)) + * + */ + __pyx_t_2 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_lb, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1698 + * + * """ + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb)) + */ + } + + /* "src/pyscipopt/scip.pxi":1700 + * if lb is None: + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb)) # <<<<<<<<<<<<<< + * + * def chgVarUbGlobal(self, Variable var, ub): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1700, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarLbGlobal(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1691 + * PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub)) + * + * def chgVarLbGlobal(self, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the global lower bound of the specified variable. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lb); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1702 + * PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb)) + * + * def chgVarUbGlobal(self, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the global upper bound of the specified variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_153chgVarUbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_152chgVarUbGlobal, "Model.chgVarUbGlobal(self, Variable var, ub)\nChanges the global upper bound of the specified variable.\n\n :param Variable var: variable to change bound of\n :param ub: new upper bound (set to None for +infinity)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_153chgVarUbGlobal = {"chgVarUbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_153chgVarUbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_152chgVarUbGlobal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_153chgVarUbGlobal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_ub = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarUbGlobal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_ub,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1702, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1702, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarUbGlobal", 1, 2, 2, 1); __PYX_ERR(0, 1702, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarUbGlobal") < 0)) __PYX_ERR(0, 1702, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_ub = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarUbGlobal", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1702, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1702, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_152chgVarUbGlobal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_ub); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_152chgVarUbGlobal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarUbGlobal", 0); + __Pyx_INCREF(__pyx_v_ub); + + /* "src/pyscipopt/scip.pxi":1709 + * + * """ + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub)) + */ + __pyx_t_1 = (__pyx_v_ub == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1710 + * """ + * if ub is None: + * ub = SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub)) + * + */ + __pyx_t_2 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_ub, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1709 + * + * """ + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub)) + */ + } + + /* "src/pyscipopt/scip.pxi":1711 + * if ub is None: + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub)) # <<<<<<<<<<<<<< + * + * def chgVarLbNode(self, Node node, Variable var, lb): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1711, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarUbGlobal(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1702 + * PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb)) + * + * def chgVarUbGlobal(self, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the global upper bound of the specified variable. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUbGlobal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ub); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1713 + * PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub)) + * + * def chgVarLbNode(self, Node node, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the lower bound of the specified variable at the given node. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_155chgVarLbNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_154chgVarLbNode, "Model.chgVarLbNode(self, Node node, Variable var, lb)\nChanges the lower bound of the specified variable at the given node.\n\n :param Variable var: variable to change bound of\n :param lb: new lower bound (set to None for -infinity)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_155chgVarLbNode = {"chgVarLbNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_155chgVarLbNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_154chgVarLbNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_155chgVarLbNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_lb = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarLbNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_node,&__pyx_n_s_var,&__pyx_n_s_lb,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_node)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1713, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1713, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarLbNode", 1, 3, 3, 1); __PYX_ERR(0, 1713, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1713, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarLbNode", 1, 3, 3, 2); __PYX_ERR(0, 1713, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarLbNode") < 0)) __PYX_ERR(0, 1713, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_node = ((struct __pyx_obj_9pyscipopt_4scip_Node *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_lb = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarLbNode", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1713, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLbNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_node), __pyx_ptype_9pyscipopt_4scip_Node, 1, "node", 0))) __PYX_ERR(0, 1713, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1713, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_154chgVarLbNode(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_node, __pyx_v_var, __pyx_v_lb); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_154chgVarLbNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarLbNode", 0); + __Pyx_INCREF(__pyx_v_lb); + + /* "src/pyscipopt/scip.pxi":1720 + * """ + * + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb)) + */ + __pyx_t_1 = (__pyx_v_lb == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1721 + * + * if lb is None: + * lb = -SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb)) + * + */ + __pyx_t_2 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1721, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_lb, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1720 + * """ + * + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb)) + */ + } + + /* "src/pyscipopt/scip.pxi":1722 + * if lb is None: + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb)) # <<<<<<<<<<<<<< + * + * def chgVarUbNode(self, Node node, Variable var, ub): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1722, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarLbNode(__pyx_v_self->_scip, __pyx_v_node->scip_node, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1713 + * PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub)) + * + * def chgVarLbNode(self, Node node, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the lower bound of the specified variable at the given node. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLbNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lb); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1724 + * PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb)) + * + * def chgVarUbNode(self, Node node, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the upper bound of the specified variable at the given node. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_157chgVarUbNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_156chgVarUbNode, "Model.chgVarUbNode(self, Node node, Variable var, ub)\nChanges the upper bound of the specified variable at the given node.\n\n :param Variable var: variable to change bound of\n :param ub: new upper bound (set to None for +infinity)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_157chgVarUbNode = {"chgVarUbNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_157chgVarUbNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_156chgVarUbNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_157chgVarUbNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_ub = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarUbNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_node,&__pyx_n_s_var,&__pyx_n_s_ub,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_node)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1724, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1724, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarUbNode", 1, 3, 3, 1); __PYX_ERR(0, 1724, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1724, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarUbNode", 1, 3, 3, 2); __PYX_ERR(0, 1724, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarUbNode") < 0)) __PYX_ERR(0, 1724, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_node = ((struct __pyx_obj_9pyscipopt_4scip_Node *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_ub = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarUbNode", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1724, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUbNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_node), __pyx_ptype_9pyscipopt_4scip_Node, 1, "node", 0))) __PYX_ERR(0, 1724, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1724, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_156chgVarUbNode(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_node, __pyx_v_var, __pyx_v_ub); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_156chgVarUbNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarUbNode", 0); + __Pyx_INCREF(__pyx_v_ub); + + /* "src/pyscipopt/scip.pxi":1731 + * + * """ + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub)) + */ + __pyx_t_1 = (__pyx_v_ub == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1732 + * """ + * if ub is None: + * ub = SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub)) + * + */ + __pyx_t_2 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1732, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_ub, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1731 + * + * """ + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub)) + */ + } + + /* "src/pyscipopt/scip.pxi":1733 + * if ub is None: + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub)) # <<<<<<<<<<<<<< + * + * def chgVarType(self, Variable var, vtype): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1733, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarUbNode(__pyx_v_self->_scip, __pyx_v_node->scip_node, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1724 + * PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb)) + * + * def chgVarUbNode(self, Node node, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the upper bound of the specified variable at the given node. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUbNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ub); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1735 + * PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub)) + * + * def chgVarType(self, Variable var, vtype): # <<<<<<<<<<<<<< + * """Changes the type of a variable + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_159chgVarType(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_158chgVarType, "Model.chgVarType(self, Variable var, vtype)\nChanges the type of a variable\n\n :param Variable var: variable to change type of\n :param vtype: new variable type\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_159chgVarType = {"chgVarType", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_159chgVarType, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_158chgVarType}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_159chgVarType(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_vtype = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarType (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_vtype,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1735, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vtype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1735, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarType", 1, 2, 2, 1); __PYX_ERR(0, 1735, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarType") < 0)) __PYX_ERR(0, 1735, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_vtype = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarType", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1735, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarType", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 1735, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_158chgVarType(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_vtype); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_158chgVarType(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_vtype) { + SCIP_Bool __pyx_v_infeasible; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarType", 1); + + /* "src/pyscipopt/scip.pxi":1743 + * """ + * cdef SCIP_Bool infeasible + * if vtype in ['C', 'CONTINUOUS']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_CONTINUOUS, &infeasible)) + * elif vtype in ['B', 'BINARY']: + */ + __Pyx_INCREF(__pyx_v_vtype); + __pyx_t_1 = __pyx_v_vtype; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_C, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 1743, __pyx_L1_error) + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_CONTINUOUS, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 1743, __pyx_L1_error) + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + if (__pyx_t_3) { + + /* "src/pyscipopt/scip.pxi":1744 + * cdef SCIP_Bool infeasible + * if vtype in ['C', 'CONTINUOUS']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_CONTINUOUS, &infeasible)) # <<<<<<<<<<<<<< + * elif vtype in ['B', 'BINARY']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_BINARY, &infeasible)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarType(__pyx_v_self->_scip, __pyx_v_var->scip_var, SCIP_VARTYPE_CONTINUOUS, (&__pyx_v_infeasible))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1743 + * """ + * cdef SCIP_Bool infeasible + * if vtype in ['C', 'CONTINUOUS']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_CONTINUOUS, &infeasible)) + * elif vtype in ['B', 'BINARY']: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":1745 + * if vtype in ['C', 'CONTINUOUS']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_CONTINUOUS, &infeasible)) + * elif vtype in ['B', 'BINARY']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_BINARY, &infeasible)) + * elif vtype in ['I', 'INTEGER']: + */ + __Pyx_INCREF(__pyx_v_vtype); + __pyx_t_1 = __pyx_v_vtype; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_B, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1745, __pyx_L1_error) + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_BINARY, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1745, __pyx_L1_error) + __pyx_t_3 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __pyx_t_3; + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1746 + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_CONTINUOUS, &infeasible)) + * elif vtype in ['B', 'BINARY']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_BINARY, &infeasible)) # <<<<<<<<<<<<<< + * elif vtype in ['I', 'INTEGER']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarType(__pyx_v_self->_scip, __pyx_v_var->scip_var, SCIP_VARTYPE_BINARY, (&__pyx_v_infeasible))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1745 + * if vtype in ['C', 'CONTINUOUS']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_CONTINUOUS, &infeasible)) + * elif vtype in ['B', 'BINARY']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_BINARY, &infeasible)) + * elif vtype in ['I', 'INTEGER']: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":1747 + * elif vtype in ['B', 'BINARY']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_BINARY, &infeasible)) + * elif vtype in ['I', 'INTEGER']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible)) + * elif vtype in ['M', 'IMPLINT']: + */ + __Pyx_INCREF(__pyx_v_vtype); + __pyx_t_1 = __pyx_v_vtype; + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_I, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 1747, __pyx_L1_error) + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_INTEGER, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 1747, __pyx_L1_error) + __pyx_t_2 = __pyx_t_3; + __pyx_L8_bool_binop_done:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + if (__pyx_t_3) { + + /* "src/pyscipopt/scip.pxi":1748 + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_BINARY, &infeasible)) + * elif vtype in ['I', 'INTEGER']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible)) # <<<<<<<<<<<<<< + * elif vtype in ['M', 'IMPLINT']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_IMPLINT, &infeasible)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarType(__pyx_v_self->_scip, __pyx_v_var->scip_var, SCIP_VARTYPE_INTEGER, (&__pyx_v_infeasible))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1747 + * elif vtype in ['B', 'BINARY']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_BINARY, &infeasible)) + * elif vtype in ['I', 'INTEGER']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible)) + * elif vtype in ['M', 'IMPLINT']: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":1749 + * elif vtype in ['I', 'INTEGER']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible)) + * elif vtype in ['M', 'IMPLINT']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_IMPLINT, &infeasible)) + * else: + */ + __Pyx_INCREF(__pyx_v_vtype); + __pyx_t_1 = __pyx_v_vtype; + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_M, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1749, __pyx_L1_error) + if (!__pyx_t_2) { + } else { + __pyx_t_3 = __pyx_t_2; + goto __pyx_L10_bool_binop_done; + } + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_IMPLINT, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1749, __pyx_L1_error) + __pyx_t_3 = __pyx_t_2; + __pyx_L10_bool_binop_done:; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __pyx_t_3; + if (likely(__pyx_t_2)) { + + /* "src/pyscipopt/scip.pxi":1750 + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible)) + * elif vtype in ['M', 'IMPLINT']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_IMPLINT, &infeasible)) # <<<<<<<<<<<<<< + * else: + * raise Warning("unrecognized variable type") + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarType(__pyx_v_self->_scip, __pyx_v_var->scip_var, SCIP_VARTYPE_IMPLINT, (&__pyx_v_infeasible))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1749 + * elif vtype in ['I', 'INTEGER']: + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible)) + * elif vtype in ['M', 'IMPLINT']: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_IMPLINT, &infeasible)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":1752 + * PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_IMPLINT, &infeasible)) + * else: + * raise Warning("unrecognized variable type") # <<<<<<<<<<<<<< + * if infeasible: + * print('could not change variable type of variable %s' % var) + */ + /*else*/ { + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1752, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1752, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":1753 + * else: + * raise Warning("unrecognized variable type") + * if infeasible: # <<<<<<<<<<<<<< + * print('could not change variable type of variable %s' % var) + * + */ + __pyx_t_2 = (__pyx_v_infeasible != 0); + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1754 + * raise Warning("unrecognized variable type") + * if infeasible: + * print('could not change variable type of variable %s' % var) # <<<<<<<<<<<<<< + * + * def getVars(self, transformed=False): + */ + __pyx_t_1 = PyUnicode_Format(__pyx_kp_u_could_not_change_variable_type_o, ((PyObject *)__pyx_v_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":1753 + * else: + * raise Warning("unrecognized variable type") + * if infeasible: # <<<<<<<<<<<<<< + * print('could not change variable type of variable %s' % var) + * + */ + } + + /* "src/pyscipopt/scip.pxi":1735 + * PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub)) + * + * def chgVarType(self, Variable var, vtype): # <<<<<<<<<<<<<< + * """Changes the type of a variable + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarType", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1756 + * print('could not change variable type of variable %s' % var) + * + * def getVars(self, transformed=False): # <<<<<<<<<<<<<< + * """Retrieve all variables. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_161getVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_160getVars, "Model.getVars(self, transformed=False)\nRetrieve all variables.\n\n :param transformed: get transformed variables instead of original (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_161getVars = {"getVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_161getVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_160getVars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_161getVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_transformed = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_transformed,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_transformed); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1756, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getVars") < 0)) __PYX_ERR(0, 1756, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_transformed = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getVars", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1756, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_160getVars(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_transformed); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_160getVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_transformed) { + SCIP_VAR **__pyx_v__vars; + int __pyx_v__nvars; + PyObject *__pyx_v_vars = NULL; + int __pyx_v_i; + size_t __pyx_v_ptr; + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVars", 1); + + /* "src/pyscipopt/scip.pxi":1765 + * cdef SCIP_VAR* _var + * cdef int _nvars + * vars = [] # <<<<<<<<<<<<<< + * + * if transformed: + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1765, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_vars = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1767 + * vars = [] + * + * if transformed: # <<<<<<<<<<<<<< + * _vars = SCIPgetVars(self._scip) + * _nvars = SCIPgetNVars(self._scip) + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_transformed); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1767, __pyx_L1_error) + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1768 + * + * if transformed: + * _vars = SCIPgetVars(self._scip) # <<<<<<<<<<<<<< + * _nvars = SCIPgetNVars(self._scip) + * else: + */ + __pyx_v__vars = SCIPgetVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":1769 + * if transformed: + * _vars = SCIPgetVars(self._scip) + * _nvars = SCIPgetNVars(self._scip) # <<<<<<<<<<<<<< + * else: + * _vars = SCIPgetOrigVars(self._scip) + */ + __pyx_v__nvars = SCIPgetNVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":1767 + * vars = [] + * + * if transformed: # <<<<<<<<<<<<<< + * _vars = SCIPgetVars(self._scip) + * _nvars = SCIPgetNVars(self._scip) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":1771 + * _nvars = SCIPgetNVars(self._scip) + * else: + * _vars = SCIPgetOrigVars(self._scip) # <<<<<<<<<<<<<< + * _nvars = SCIPgetNOrigVars(self._scip) + * + */ + /*else*/ { + __pyx_v__vars = SCIPgetOrigVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":1772 + * else: + * _vars = SCIPgetOrigVars(self._scip) + * _nvars = SCIPgetNOrigVars(self._scip) # <<<<<<<<<<<<<< + * + * for i in range(_nvars): + */ + __pyx_v__nvars = SCIPgetNOrigVars(__pyx_v_self->_scip); + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":1774 + * _nvars = SCIPgetNOrigVars(self._scip) + * + * for i in range(_nvars): # <<<<<<<<<<<<<< + * ptr = (_vars[i]) + * + */ + __pyx_t_3 = __pyx_v__nvars; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "src/pyscipopt/scip.pxi":1775 + * + * for i in range(_nvars): + * ptr = (_vars[i]) # <<<<<<<<<<<<<< + * + * # check whether the corresponding variable exists already + */ + __pyx_v_ptr = ((size_t)(__pyx_v__vars[__pyx_v_i])); + + /* "src/pyscipopt/scip.pxi":1778 + * + * # check whether the corresponding variable exists already + * if ptr in self._modelvars: # <<<<<<<<<<<<<< + * vars.append(self._modelvars[ptr]) + * else: + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_ptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_v_self->_modelvars, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1778, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":1779 + * # check whether the corresponding variable exists already + * if ptr in self._modelvars: + * vars.append(self._modelvars[ptr]) # <<<<<<<<<<<<<< + * else: + * # create a new variable + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_self->_modelvars, __pyx_v_ptr, size_t, 0, __Pyx_PyInt_FromSize_t, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_vars, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 1779, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1778 + * + * # check whether the corresponding variable exists already + * if ptr in self._modelvars: # <<<<<<<<<<<<<< + * vars.append(self._modelvars[ptr]) + * else: + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/scip.pxi":1782 + * else: + * # create a new variable + * var = Variable.create(_vars[i]) # <<<<<<<<<<<<<< + * assert var.ptr() == ptr + * self._modelvars[ptr] = var + */ + /*else*/ { + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v__vars[__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1783 + * # create a new variable + * var = Variable.create(_vars[i]) + * assert var.ptr() == ptr # <<<<<<<<<<<<<< + * self._modelvars[ptr] = var + * vars.append(var) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_ptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_9, 0+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_ptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyObject_RichCompare(__pyx_t_1, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1783, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1783, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 1783, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 1783, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":1784 + * var = Variable.create(_vars[i]) + * assert var.ptr() == ptr + * self._modelvars[ptr] = var # <<<<<<<<<<<<<< + * vars.append(var) + * + */ + if (unlikely((__Pyx_SetItemInt(__pyx_v_self->_modelvars, __pyx_v_ptr, __pyx_v_var, size_t, 0, __Pyx_PyInt_FromSize_t, 0, 0, 1) < 0))) __PYX_ERR(0, 1784, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1785 + * assert var.ptr() == ptr + * self._modelvars[ptr] = var + * vars.append(var) # <<<<<<<<<<<<<< + * + * return vars + */ + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_vars, __pyx_v_var); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 1785, __pyx_L1_error) + } + __pyx_L6:; + } + + /* "src/pyscipopt/scip.pxi":1787 + * vars.append(var) + * + * return vars # <<<<<<<<<<<<<< + * + * def getNVars(self, transformed=True): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_vars); + __pyx_r = __pyx_v_vars; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1756 + * print('could not change variable type of variable %s' % var) + * + * def getVars(self, transformed=False): # <<<<<<<<<<<<<< + * """Retrieve all variables. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.getVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_vars); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1789 + * return vars + * + * def getNVars(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve number of variables in the problems. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_163getNVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_162getNVars, "Model.getNVars(self, transformed=True)\nRetrieve number of variables in the problems.\n \n :param transformed: get transformed variables instead of original (Default value = True)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_163getNVars = {"getNVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_163getNVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_162getNVars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_163getNVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_transformed = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNVars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_transformed,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_transformed); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1789, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getNVars") < 0)) __PYX_ERR(0, 1789, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_transformed = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getNVars", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 1789, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getNVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_162getNVars(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_transformed); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_162getNVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_transformed) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNVars", 1); + + /* "src/pyscipopt/scip.pxi":1794 + * :param transformed: get transformed variables instead of original (Default value = True) + * """ + * if transformed: # <<<<<<<<<<<<<< + * return SCIPgetNVars(self._scip) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_transformed); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 1794, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":1795 + * """ + * if transformed: + * return SCIPgetNVars(self._scip) # <<<<<<<<<<<<<< + * else: + * return SCIPgetNOrigVars(self._scip) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(SCIPgetNVars(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1795, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1794 + * :param transformed: get transformed variables instead of original (Default value = True) + * """ + * if transformed: # <<<<<<<<<<<<<< + * return SCIPgetNVars(self._scip) + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":1797 + * return SCIPgetNVars(self._scip) + * else: + * return SCIPgetNOrigVars(self._scip) # <<<<<<<<<<<<<< + * + * def getNIntVars(self): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(SCIPgetNOrigVars(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1797, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":1789 + * return vars + * + * def getNVars(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve number of variables in the problems. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1799 + * return SCIPgetNOrigVars(self._scip) + * + * def getNIntVars(self): # <<<<<<<<<<<<<< + * """gets number of integer active problem variables""" + * return SCIPgetNIntVars(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_165getNIntVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_164getNIntVars, "Model.getNIntVars(self)\ngets number of integer active problem variables"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_165getNIntVars = {"getNIntVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_165getNIntVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_164getNIntVars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_165getNIntVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNIntVars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNIntVars", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNIntVars", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_164getNIntVars(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_164getNIntVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNIntVars", 1); + + /* "src/pyscipopt/scip.pxi":1801 + * def getNIntVars(self): + * """gets number of integer active problem variables""" + * return SCIPgetNIntVars(self._scip) # <<<<<<<<<<<<<< + * + * def getNBinVars(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNIntVars(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1801, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1799 + * return SCIPgetNOrigVars(self._scip) + * + * def getNIntVars(self): # <<<<<<<<<<<<<< + * """gets number of integer active problem variables""" + * return SCIPgetNIntVars(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNIntVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1803 + * return SCIPgetNIntVars(self._scip) + * + * def getNBinVars(self): # <<<<<<<<<<<<<< + * """gets number of binary active problem variables""" + * return SCIPgetNBinVars(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_167getNBinVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_166getNBinVars, "Model.getNBinVars(self)\ngets number of binary active problem variables"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_167getNBinVars = {"getNBinVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_167getNBinVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_166getNBinVars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_167getNBinVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNBinVars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNBinVars", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNBinVars", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_166getNBinVars(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_166getNBinVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNBinVars", 1); + + /* "src/pyscipopt/scip.pxi":1805 + * def getNBinVars(self): + * """gets number of binary active problem variables""" + * return SCIPgetNBinVars(self._scip) # <<<<<<<<<<<<<< + * + * def getVarDict(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNBinVars(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1805, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1803 + * return SCIPgetNIntVars(self._scip) + * + * def getNBinVars(self): # <<<<<<<<<<<<<< + * """gets number of binary active problem variables""" + * return SCIPgetNBinVars(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNBinVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1807 + * return SCIPgetNBinVars(self._scip) + * + * def getVarDict(self): # <<<<<<<<<<<<<< + * """gets dictionary with variables names as keys and current variable values as items""" + * var_dict = {} + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_169getVarDict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_168getVarDict, "Model.getVarDict(self)\ngets dictionary with variables names as keys and current variable values as items"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_169getVarDict = {"getVarDict", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_169getVarDict, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_168getVarDict}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_169getVarDict(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVarDict (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getVarDict", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getVarDict", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_168getVarDict(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_168getVarDict(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_v_var_dict = NULL; + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVarDict", 1); + + /* "src/pyscipopt/scip.pxi":1809 + * def getVarDict(self): + * """gets dictionary with variables names as keys and current variable values as items""" + * var_dict = {} # <<<<<<<<<<<<<< + * for var in self.getVars(): + * var_dict[var.name] = self.getVal(var) + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1809, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_var_dict = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1810 + * """gets dictionary with variables names as keys and current variable values as items""" + * var_dict = {} + * for var in self.getVars(): # <<<<<<<<<<<<<< + * var_dict[var.name] = self.getVal(var) + * return var_dict + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getVars); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1810, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1810, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 1810, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1810, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 1810, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_6(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 1810, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1811 + * var_dict = {} + * for var in self.getVars(): + * var_dict[var.name] = self.getVal(var) # <<<<<<<<<<<<<< + * return var_dict + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getVal); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1811, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_var}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1811, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1811, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely((PyDict_SetItem(__pyx_v_var_dict, __pyx_t_3, __pyx_t_1) < 0))) __PYX_ERR(0, 1811, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1810 + * """gets dictionary with variables names as keys and current variable values as items""" + * var_dict = {} + * for var in self.getVars(): # <<<<<<<<<<<<<< + * var_dict[var.name] = self.getVal(var) + * return var_dict + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1812 + * for var in self.getVars(): + * var_dict[var.name] = self.getVal(var) + * return var_dict # <<<<<<<<<<<<<< + * + * def updateNodeLowerbound(self, Node node, lb): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_var_dict); + __pyx_r = __pyx_v_var_dict; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1807 + * return SCIPgetNBinVars(self._scip) + * + * def getVarDict(self): # <<<<<<<<<<<<<< + * """gets dictionary with variables names as keys and current variable values as items""" + * var_dict = {} + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.getVarDict", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_var_dict); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1814 + * return var_dict + * + * def updateNodeLowerbound(self, Node node, lb): # <<<<<<<<<<<<<< + * """if given value is larger than the node's lower bound (in transformed problem), + * sets the node's lower bound to the new value + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_171updateNodeLowerbound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_170updateNodeLowerbound, "Model.updateNodeLowerbound(self, Node node, lb)\nif given value is larger than the node's lower bound (in transformed problem),\n sets the node's lower bound to the new value\n\n :param node: Node, the node to update\n :param newbound: float, new bound (if greater) for the node\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_171updateNodeLowerbound = {"updateNodeLowerbound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_171updateNodeLowerbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_170updateNodeLowerbound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_171updateNodeLowerbound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node = 0; + PyObject *__pyx_v_lb = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("updateNodeLowerbound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_node,&__pyx_n_s_lb,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_node)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1814, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1814, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("updateNodeLowerbound", 1, 2, 2, 1); __PYX_ERR(0, 1814, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "updateNodeLowerbound") < 0)) __PYX_ERR(0, 1814, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_node = ((struct __pyx_obj_9pyscipopt_4scip_Node *)values[0]); + __pyx_v_lb = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("updateNodeLowerbound", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1814, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.updateNodeLowerbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_node), __pyx_ptype_9pyscipopt_4scip_Node, 1, "node", 0))) __PYX_ERR(0, 1814, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_170updateNodeLowerbound(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_node, __pyx_v_lb); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_170updateNodeLowerbound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node, PyObject *__pyx_v_lb) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("updateNodeLowerbound", 1); + + /* "src/pyscipopt/scip.pxi":1822 + * + * """ + * PY_SCIP_CALL(SCIPupdateNodeLowerbound(self._scip, node.scip_node, lb)) # <<<<<<<<<<<<<< + * + * def relax(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1822, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPupdateNodeLowerbound(__pyx_v_self->_scip, __pyx_v_node->scip_node, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1814 + * return var_dict + * + * def updateNodeLowerbound(self, Node node, lb): # <<<<<<<<<<<<<< + * """if given value is larger than the node's lower bound (in transformed problem), + * sets the node's lower bound to the new value + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.updateNodeLowerbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1824 + * PY_SCIP_CALL(SCIPupdateNodeLowerbound(self._scip, node.scip_node, lb)) + * + * def relax(self): # <<<<<<<<<<<<<< + * """Relaxes the integrality restrictions of the model""" + * if self.getStage() != SCIP_STAGE_PROBLEM: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_173relax(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_172relax, "Model.relax(self)\nRelaxes the integrality restrictions of the model"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_173relax = {"relax", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_173relax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_172relax}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_173relax(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("relax (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("relax", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "relax", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_172relax(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_172relax(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("relax", 1); + + /* "src/pyscipopt/scip.pxi":1826 + * def relax(self): + * """Relaxes the integrality restrictions of the model""" + * if self.getStage() != SCIP_STAGE_PROBLEM: # <<<<<<<<<<<<<< + * raise Warning("method can only be called in stage PROBLEM") + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_PROBLEM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1826, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 1826, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_5)) { + + /* "src/pyscipopt/scip.pxi":1827 + * """Relaxes the integrality restrictions of the model""" + * if self.getStage() != SCIP_STAGE_PROBLEM: + * raise Warning("method can only be called in stage PROBLEM") # <<<<<<<<<<<<<< + * + * for var in self.getVars(): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__91, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1827, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 1827, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1826 + * def relax(self): + * """Relaxes the integrality restrictions of the model""" + * if self.getStage() != SCIP_STAGE_PROBLEM: # <<<<<<<<<<<<<< + * raise Warning("method can only be called in stage PROBLEM") + * + */ + } + + /* "src/pyscipopt/scip.pxi":1829 + * raise Warning("method can only be called in stage PROBLEM") + * + * for var in self.getVars(): # <<<<<<<<<<<<<< + * self.chgVarType(var, "C") + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getVars); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1829, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1829, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1829, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1829, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1829, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 1829, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1829, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 1829, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 1829, __pyx_L1_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1829, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_7(__pyx_t_2); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 1829, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1830 + * + * for var in self.getVars(): + * self.chgVarType(var, "C") # <<<<<<<<<<<<<< + * + * # Node methods + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_chgVarType); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_var, __pyx_n_u_C}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":1829 + * raise Warning("method can only be called in stage PROBLEM") + * + * for var in self.getVars(): # <<<<<<<<<<<<<< + * self.chgVarType(var, "C") + * + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":1824 + * PY_SCIP_CALL(SCIPupdateNodeLowerbound(self._scip, node.scip_node, lb)) + * + * def relax(self): # <<<<<<<<<<<<<< + * """Relaxes the integrality restrictions of the model""" + * if self.getStage() != SCIP_STAGE_PROBLEM: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.relax", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1833 + * + * # Node methods + * def getBestChild(self): # <<<<<<<<<<<<<< + * """gets the best child of the focus node w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestChild(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_175getBestChild(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_174getBestChild, "Model.getBestChild(self)\ngets the best child of the focus node w.r.t. the node selection strategy."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_175getBestChild = {"getBestChild", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_175getBestChild, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_174getBestChild}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_175getBestChild(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBestChild (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBestChild", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBestChild", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_174getBestChild(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_174getBestChild(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBestChild", 1); + + /* "src/pyscipopt/scip.pxi":1835 + * def getBestChild(self): + * """gets the best child of the focus node w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestChild(self._scip)) # <<<<<<<<<<<<<< + * + * def getBestSibling(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(SCIPgetBestChild(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1833 + * + * # Node methods + * def getBestChild(self): # <<<<<<<<<<<<<< + * """gets the best child of the focus node w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestChild(self._scip)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBestChild", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1837 + * return Node.create(SCIPgetBestChild(self._scip)) + * + * def getBestSibling(self): # <<<<<<<<<<<<<< + * """gets the best sibling of the focus node w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestSibling(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_177getBestSibling(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_176getBestSibling, "Model.getBestSibling(self)\ngets the best sibling of the focus node w.r.t. the node selection strategy."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_177getBestSibling = {"getBestSibling", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_177getBestSibling, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_176getBestSibling}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_177getBestSibling(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBestSibling (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBestSibling", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBestSibling", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_176getBestSibling(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_176getBestSibling(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBestSibling", 1); + + /* "src/pyscipopt/scip.pxi":1839 + * def getBestSibling(self): + * """gets the best sibling of the focus node w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestSibling(self._scip)) # <<<<<<<<<<<<<< + * + * def getBestLeaf(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(SCIPgetBestSibling(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1837 + * return Node.create(SCIPgetBestChild(self._scip)) + * + * def getBestSibling(self): # <<<<<<<<<<<<<< + * """gets the best sibling of the focus node w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestSibling(self._scip)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBestSibling", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1841 + * return Node.create(SCIPgetBestSibling(self._scip)) + * + * def getBestLeaf(self): # <<<<<<<<<<<<<< + * """gets the best leaf from the node queue w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestLeaf(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_179getBestLeaf(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_178getBestLeaf, "Model.getBestLeaf(self)\ngets the best leaf from the node queue w.r.t. the node selection strategy."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_179getBestLeaf = {"getBestLeaf", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_179getBestLeaf, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_178getBestLeaf}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_179getBestLeaf(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBestLeaf (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBestLeaf", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBestLeaf", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_178getBestLeaf(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_178getBestLeaf(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBestLeaf", 1); + + /* "src/pyscipopt/scip.pxi":1843 + * def getBestLeaf(self): + * """gets the best leaf from the node queue w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestLeaf(self._scip)) # <<<<<<<<<<<<<< + * + * def getBestNode(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(SCIPgetBestLeaf(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1843, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1841 + * return Node.create(SCIPgetBestSibling(self._scip)) + * + * def getBestLeaf(self): # <<<<<<<<<<<<<< + * """gets the best leaf from the node queue w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestLeaf(self._scip)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBestLeaf", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1845 + * return Node.create(SCIPgetBestLeaf(self._scip)) + * + * def getBestNode(self): # <<<<<<<<<<<<<< + * """gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestNode(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_181getBestNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_180getBestNode, "Model.getBestNode(self)\ngets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_181getBestNode = {"getBestNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_181getBestNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_180getBestNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_181getBestNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBestNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBestNode", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBestNode", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_180getBestNode(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_180getBestNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBestNode", 1); + + /* "src/pyscipopt/scip.pxi":1847 + * def getBestNode(self): + * """gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestNode(self._scip)) # <<<<<<<<<<<<<< + * + * def getBestboundNode(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(SCIPgetBestNode(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1847, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1845 + * return Node.create(SCIPgetBestLeaf(self._scip)) + * + * def getBestNode(self): # <<<<<<<<<<<<<< + * """gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestNode(self._scip)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBestNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1849 + * return Node.create(SCIPgetBestNode(self._scip)) + * + * def getBestboundNode(self): # <<<<<<<<<<<<<< + * """gets the node with smallest lower bound from the tree (child, sibling, or leaf).""" + * return Node.create(SCIPgetBestboundNode(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_183getBestboundNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_182getBestboundNode, "Model.getBestboundNode(self)\ngets the node with smallest lower bound from the tree (child, sibling, or leaf)."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_183getBestboundNode = {"getBestboundNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_183getBestboundNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_182getBestboundNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_183getBestboundNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBestboundNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBestboundNode", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBestboundNode", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_182getBestboundNode(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_182getBestboundNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBestboundNode", 1); + + /* "src/pyscipopt/scip.pxi":1851 + * def getBestboundNode(self): + * """gets the node with smallest lower bound from the tree (child, sibling, or leaf).""" + * return Node.create(SCIPgetBestboundNode(self._scip)) # <<<<<<<<<<<<<< + * + * def getOpenNodes(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(SCIPgetBestboundNode(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1849 + * return Node.create(SCIPgetBestNode(self._scip)) + * + * def getBestboundNode(self): # <<<<<<<<<<<<<< + * """gets the node with smallest lower bound from the tree (child, sibling, or leaf).""" + * return Node.create(SCIPgetBestboundNode(self._scip)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBestboundNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1853 + * return Node.create(SCIPgetBestboundNode(self._scip)) + * + * def getOpenNodes(self): # <<<<<<<<<<<<<< + * """access to all data of open nodes (leaves, children, and siblings) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_185getOpenNodes(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_184getOpenNodes, "Model.getOpenNodes(self)\naccess to all data of open nodes (leaves, children, and siblings)\n\n :return: three lists containing open leaves, children, siblings\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_185getOpenNodes = {"getOpenNodes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_185getOpenNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_184getOpenNodes}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_185getOpenNodes(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getOpenNodes (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getOpenNodes", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getOpenNodes", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_184getOpenNodes(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_184getOpenNodes(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_NODE **__pyx_v__leaves; + SCIP_NODE **__pyx_v__children; + SCIP_NODE **__pyx_v__siblings; + int __pyx_v__nleaves; + int __pyx_v__nchildren; + int __pyx_v__nsiblings; + PyObject *__pyx_v_leaves = NULL; + PyObject *__pyx_v_children = NULL; + PyObject *__pyx_v_siblings = NULL; + int __pyx_9genexpr27__pyx_v_i; + int __pyx_9genexpr28__pyx_v_i; + int __pyx_9genexpr29__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getOpenNodes", 1); + + /* "src/pyscipopt/scip.pxi":1865 + * cdef int _nsiblings + * + * PY_SCIP_CALL(SCIPgetOpenNodesData(self._scip, &_leaves, &_children, &_siblings, &_nleaves, &_nchildren, &_nsiblings)) # <<<<<<<<<<<<<< + * + * leaves = [Node.create(_leaves[i]) for i in range(_nleaves)] + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetOpenNodesData(__pyx_v_self->_scip, (&__pyx_v__leaves), (&__pyx_v__children), (&__pyx_v__siblings), (&__pyx_v__nleaves), (&__pyx_v__nchildren), (&__pyx_v__nsiblings))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1867 + * PY_SCIP_CALL(SCIPgetOpenNodesData(self._scip, &_leaves, &_children, &_siblings, &_nleaves, &_nchildren, &_nsiblings)) + * + * leaves = [Node.create(_leaves[i]) for i in range(_nleaves)] # <<<<<<<<<<<<<< + * children = [Node.create(_children[i]) for i in range(_nchildren)] + * siblings = [Node.create(_siblings[i]) for i in range(_nsiblings)] + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_v__nleaves; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr27__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_4Node_create((__pyx_v__leaves[__pyx_9genexpr27__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1867, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_leaves = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1868 + * + * leaves = [Node.create(_leaves[i]) for i in range(_nleaves)] + * children = [Node.create(_children[i]) for i in range(_nchildren)] # <<<<<<<<<<<<<< + * siblings = [Node.create(_siblings[i]) for i in range(_nsiblings)] + * + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1868, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_v__nchildren; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr28__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_4Node_create((__pyx_v__children[__pyx_9genexpr28__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1868, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1868, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_children = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1869 + * leaves = [Node.create(_leaves[i]) for i in range(_nleaves)] + * children = [Node.create(_children[i]) for i in range(_nchildren)] + * siblings = [Node.create(_siblings[i]) for i in range(_nsiblings)] # <<<<<<<<<<<<<< + * + * return leaves, children, siblings + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_v__nsiblings; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr29__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_4Node_create((__pyx_v__siblings[__pyx_9genexpr29__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1869, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_siblings = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1871 + * siblings = [Node.create(_siblings[i]) for i in range(_nsiblings)] + * + * return leaves, children, siblings # <<<<<<<<<<<<<< + * + * def repropagateNode(self, Node node): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1871, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_leaves); + __Pyx_GIVEREF(__pyx_v_leaves); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_leaves)) __PYX_ERR(0, 1871, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_children); + __Pyx_GIVEREF(__pyx_v_children); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_children)) __PYX_ERR(0, 1871, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_siblings); + __Pyx_GIVEREF(__pyx_v_siblings); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_siblings)) __PYX_ERR(0, 1871, __pyx_L1_error); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1853 + * return Node.create(SCIPgetBestboundNode(self._scip)) + * + * def getOpenNodes(self): # <<<<<<<<<<<<<< + * """access to all data of open nodes (leaves, children, and siblings) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getOpenNodes", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_leaves); + __Pyx_XDECREF(__pyx_v_children); + __Pyx_XDECREF(__pyx_v_siblings); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1873 + * return leaves, children, siblings + * + * def repropagateNode(self, Node node): # <<<<<<<<<<<<<< + * """marks the given node to be propagated again the next time a node of its subtree is processed""" + * PY_SCIP_CALL(SCIPrepropagateNode(self._scip, node.scip_node)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_187repropagateNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_186repropagateNode, "Model.repropagateNode(self, Node node)\nmarks the given node to be propagated again the next time a node of its subtree is processed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_187repropagateNode = {"repropagateNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_187repropagateNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_186repropagateNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_187repropagateNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("repropagateNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_node,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_node)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1873, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "repropagateNode") < 0)) __PYX_ERR(0, 1873, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_node = ((struct __pyx_obj_9pyscipopt_4scip_Node *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("repropagateNode", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1873, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.repropagateNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_node), __pyx_ptype_9pyscipopt_4scip_Node, 1, "node", 0))) __PYX_ERR(0, 1873, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_186repropagateNode(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_node); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_186repropagateNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("repropagateNode", 1); + + /* "src/pyscipopt/scip.pxi":1875 + * def repropagateNode(self, Node node): + * """marks the given node to be propagated again the next time a node of its subtree is processed""" + * PY_SCIP_CALL(SCIPrepropagateNode(self._scip, node.scip_node)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1875, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPrepropagateNode(__pyx_v_self->_scip, __pyx_v_node->scip_node)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1875, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1875, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1873 + * return leaves, children, siblings + * + * def repropagateNode(self, Node node): # <<<<<<<<<<<<<< + * """marks the given node to be propagated again the next time a node of its subtree is processed""" + * PY_SCIP_CALL(SCIPrepropagateNode(self._scip, node.scip_node)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.repropagateNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1879 + * + * # LP Methods + * def getLPSolstat(self): # <<<<<<<<<<<<<< + * """Gets solution status of current LP""" + * return SCIPgetLPSolstat(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_189getLPSolstat(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_188getLPSolstat, "Model.getLPSolstat(self)\nGets solution status of current LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_189getLPSolstat = {"getLPSolstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_189getLPSolstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_188getLPSolstat}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_189getLPSolstat(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPSolstat (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPSolstat", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPSolstat", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_188getLPSolstat(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_188getLPSolstat(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPSolstat", 1); + + /* "src/pyscipopt/scip.pxi":1881 + * def getLPSolstat(self): + * """Gets solution status of current LP""" + * return SCIPgetLPSolstat(self._scip) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIPgetLPSolstat(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1881, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1879 + * + * # LP Methods + * def getLPSolstat(self): # <<<<<<<<<<<<<< + * """Gets solution status of current LP""" + * return SCIPgetLPSolstat(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPSolstat", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1884 + * + * + * def constructLP(self): # <<<<<<<<<<<<<< + * """makes sure that the LP of the current node is loaded and + * may be accessed through the LP information methods + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_191constructLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_190constructLP, "Model.constructLP(self)\nmakes sure that the LP of the current node is loaded and\n may be accessed through the LP information methods\n\n :return: bool cutoff, i.e. can the node be cut off?\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_191constructLP = {"constructLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_191constructLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_190constructLP}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_191constructLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("constructLP (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("constructLP", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "constructLP", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_190constructLP(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_190constructLP(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_Bool __pyx_v_cutoff; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("constructLP", 1); + + /* "src/pyscipopt/scip.pxi":1892 + * """ + * cdef SCIP_Bool cutoff + * PY_SCIP_CALL(SCIPconstructLP(self._scip, &cutoff)) # <<<<<<<<<<<<<< + * return cutoff + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPconstructLP(__pyx_v_self->_scip, (&__pyx_v_cutoff))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1893 + * cdef SCIP_Bool cutoff + * PY_SCIP_CALL(SCIPconstructLP(self._scip, &cutoff)) + * return cutoff # <<<<<<<<<<<<<< + * + * def getLPObjVal(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_cutoff); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1893, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1884 + * + * + * def constructLP(self): # <<<<<<<<<<<<<< + * """makes sure that the LP of the current node is loaded and + * may be accessed through the LP information methods + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.constructLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1895 + * return cutoff + * + * def getLPObjVal(self): # <<<<<<<<<<<<<< + * """gets objective value of current LP (which is the sum of column and loose objective value)""" + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_193getLPObjVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_192getLPObjVal, "Model.getLPObjVal(self)\ngets objective value of current LP (which is the sum of column and loose objective value)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_193getLPObjVal = {"getLPObjVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_193getLPObjVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_192getLPObjVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_193getLPObjVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPObjVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPObjVal", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPObjVal", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_192getLPObjVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_192getLPObjVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPObjVal", 1); + + /* "src/pyscipopt/scip.pxi":1898 + * """gets objective value of current LP (which is the sum of column and loose objective value)""" + * + * return SCIPgetLPObjval(self._scip) # <<<<<<<<<<<<<< + * + * def getLPColsData(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetLPObjval(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1898, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1895 + * return cutoff + * + * def getLPObjVal(self): # <<<<<<<<<<<<<< + * """gets objective value of current LP (which is the sum of column and loose objective value)""" + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPObjVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1900 + * return SCIPgetLPObjval(self._scip) + * + * def getLPColsData(self): # <<<<<<<<<<<<<< + * """Retrieve current LP columns""" + * cdef SCIP_COL** cols + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_195getLPColsData(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_194getLPColsData, "Model.getLPColsData(self)\nRetrieve current LP columns"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_195getLPColsData = {"getLPColsData", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_195getLPColsData, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_194getLPColsData}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_195getLPColsData(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPColsData (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPColsData", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPColsData", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_194getLPColsData(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_194getLPColsData(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_COL **__pyx_v_cols; + int __pyx_v_ncols; + int __pyx_9genexpr30__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPColsData", 1); + + /* "src/pyscipopt/scip.pxi":1905 + * cdef int ncols + * + * PY_SCIP_CALL(SCIPgetLPColsData(self._scip, &cols, &ncols)) # <<<<<<<<<<<<<< + * return [Column.create(cols[i]) for i in range(ncols)] + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1905, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetLPColsData(__pyx_v_self->_scip, (&__pyx_v_cols), (&__pyx_v_ncols))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1905, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1905, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1906 + * + * PY_SCIP_CALL(SCIPgetLPColsData(self._scip, &cols, &ncols)) + * return [Column.create(cols[i]) for i in range(ncols)] # <<<<<<<<<<<<<< + * + * def getLPRowsData(self): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1906, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_v_ncols; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr30__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_6Column_create((__pyx_v_cols[__pyx_9genexpr30__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1906, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1906, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1900 + * return SCIPgetLPObjval(self._scip) + * + * def getLPColsData(self): # <<<<<<<<<<<<<< + * """Retrieve current LP columns""" + * cdef SCIP_COL** cols + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPColsData", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1908 + * return [Column.create(cols[i]) for i in range(ncols)] + * + * def getLPRowsData(self): # <<<<<<<<<<<<<< + * """Retrieve current LP rows""" + * cdef SCIP_ROW** rows + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_197getLPRowsData(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_196getLPRowsData, "Model.getLPRowsData(self)\nRetrieve current LP rows"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_197getLPRowsData = {"getLPRowsData", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_197getLPRowsData, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_196getLPRowsData}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_197getLPRowsData(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPRowsData (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPRowsData", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPRowsData", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_196getLPRowsData(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_196getLPRowsData(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_ROW **__pyx_v_rows; + int __pyx_v_nrows; + int __pyx_9genexpr31__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPRowsData", 1); + + /* "src/pyscipopt/scip.pxi":1913 + * cdef int nrows + * + * PY_SCIP_CALL(SCIPgetLPRowsData(self._scip, &rows, &nrows)) # <<<<<<<<<<<<<< + * return [Row.create(rows[i]) for i in range(nrows)] + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetLPRowsData(__pyx_v_self->_scip, (&__pyx_v_rows), (&__pyx_v_nrows))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1914 + * + * PY_SCIP_CALL(SCIPgetLPRowsData(self._scip, &rows, &nrows)) + * return [Row.create(rows[i]) for i in range(nrows)] # <<<<<<<<<<<<<< + * + * def getNLPRows(self): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_v_nrows; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr31__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_3Row_create((__pyx_v_rows[__pyx_9genexpr31__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1908 + * return [Column.create(cols[i]) for i in range(ncols)] + * + * def getLPRowsData(self): # <<<<<<<<<<<<<< + * """Retrieve current LP rows""" + * cdef SCIP_ROW** rows + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPRowsData", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1916 + * return [Row.create(rows[i]) for i in range(nrows)] + * + * def getNLPRows(self): # <<<<<<<<<<<<<< + * """Retrieve the number of rows currently in the LP""" + * return SCIPgetNLPRows(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_199getNLPRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_198getNLPRows, "Model.getNLPRows(self)\nRetrieve the number of rows currently in the LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_199getNLPRows = {"getNLPRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_199getNLPRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_198getNLPRows}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_199getNLPRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNLPRows (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNLPRows", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLPRows", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_198getNLPRows(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_198getNLPRows(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNLPRows", 1); + + /* "src/pyscipopt/scip.pxi":1918 + * def getNLPRows(self): + * """Retrieve the number of rows currently in the LP""" + * return SCIPgetNLPRows(self._scip) # <<<<<<<<<<<<<< + * + * def getNLPCols(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNLPRows(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1916 + * return [Row.create(rows[i]) for i in range(nrows)] + * + * def getNLPRows(self): # <<<<<<<<<<<<<< + * """Retrieve the number of rows currently in the LP""" + * return SCIPgetNLPRows(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNLPRows", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1920 + * return SCIPgetNLPRows(self._scip) + * + * def getNLPCols(self): # <<<<<<<<<<<<<< + * """Retrieve the number of cols currently in the LP""" + * return SCIPgetNLPCols(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_201getNLPCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_200getNLPCols, "Model.getNLPCols(self)\nRetrieve the number of cols currently in the LP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_201getNLPCols = {"getNLPCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_201getNLPCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_200getNLPCols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_201getNLPCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNLPCols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNLPCols", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLPCols", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_200getNLPCols(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_200getNLPCols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNLPCols", 1); + + /* "src/pyscipopt/scip.pxi":1922 + * def getNLPCols(self): + * """Retrieve the number of cols currently in the LP""" + * return SCIPgetNLPCols(self._scip) # <<<<<<<<<<<<<< + * + * def getLPBasisInd(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNLPCols(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1920 + * return SCIPgetNLPRows(self._scip) + * + * def getNLPCols(self): # <<<<<<<<<<<<<< + * """Retrieve the number of cols currently in the LP""" + * return SCIPgetNLPCols(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNLPCols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1924 + * return SCIPgetNLPCols(self._scip) + * + * def getLPBasisInd(self): # <<<<<<<<<<<<<< + * """Gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * cdef int nrows = SCIPgetNLPRows(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_203getLPBasisInd(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_202getLPBasisInd, "Model.getLPBasisInd(self)\nGets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_203getLPBasisInd = {"getLPBasisInd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_203getLPBasisInd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_202getLPBasisInd}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_203getLPBasisInd(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPBasisInd (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPBasisInd", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPBasisInd", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_202getLPBasisInd(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_202getLPBasisInd(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + int __pyx_v_nrows; + int *__pyx_v_inds; + PyObject *__pyx_v_result = NULL; + int __pyx_9genexpr32__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPBasisInd", 1); + + /* "src/pyscipopt/scip.pxi":1926 + * def getLPBasisInd(self): + * """Gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * cdef int nrows = SCIPgetNLPRows(self._scip) # <<<<<<<<<<<<<< + * cdef int* inds = malloc(nrows * sizeof(int)) + * + */ + __pyx_v_nrows = SCIPgetNLPRows(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":1927 + * """Gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * cdef int nrows = SCIPgetNLPRows(self._scip) + * cdef int* inds = malloc(nrows * sizeof(int)) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPgetLPBasisInd(self._scip, inds)) + */ + __pyx_v_inds = ((int *)malloc((__pyx_v_nrows * (sizeof(int))))); + + /* "src/pyscipopt/scip.pxi":1929 + * cdef int* inds = malloc(nrows * sizeof(int)) + * + * PY_SCIP_CALL(SCIPgetLPBasisInd(self._scip, inds)) # <<<<<<<<<<<<<< + * result = [inds[i] for i in range(nrows)] + * free(inds) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetLPBasisInd(__pyx_v_self->_scip, __pyx_v_inds)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1930 + * + * PY_SCIP_CALL(SCIPgetLPBasisInd(self._scip, inds)) + * result = [inds[i] for i in range(nrows)] # <<<<<<<<<<<<<< + * free(inds) + * return result + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_v_nrows; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr32__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_v_inds[__pyx_9genexpr32__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1930, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1931 + * PY_SCIP_CALL(SCIPgetLPBasisInd(self._scip, inds)) + * result = [inds[i] for i in range(nrows)] + * free(inds) # <<<<<<<<<<<<<< + * return result + * + */ + free(__pyx_v_inds); + + /* "src/pyscipopt/scip.pxi":1932 + * result = [inds[i] for i in range(nrows)] + * free(inds) + * return result # <<<<<<<<<<<<<< + * + * def getLPBInvRow(self, row): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1924 + * return SCIPgetNLPCols(self._scip) + * + * def getLPBasisInd(self): # <<<<<<<<<<<<<< + * """Gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * cdef int nrows = SCIPgetNLPRows(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPBasisInd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1934 + * return result + * + * def getLPBInvRow(self, row): # <<<<<<<<<<<<<< + * """gets a row from the inverse basis matrix B^-1""" + * # TODO: sparsity information + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_205getLPBInvRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_204getLPBInvRow, "Model.getLPBInvRow(self, row)\ngets a row from the inverse basis matrix B^-1"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_205getLPBInvRow = {"getLPBInvRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_205getLPBInvRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_204getLPBInvRow}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_205getLPBInvRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPBInvRow (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1934, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getLPBInvRow") < 0)) __PYX_ERR(0, 1934, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getLPBInvRow", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1934, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPBInvRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_204getLPBInvRow(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_204getLPBInvRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_row) { + int __pyx_v_nrows; + SCIP_Real *__pyx_v_coefs; + PyObject *__pyx_v_result = NULL; + int __pyx_9genexpr33__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPBInvRow", 1); + + /* "src/pyscipopt/scip.pxi":1937 + * """gets a row from the inverse basis matrix B^-1""" + * # TODO: sparsity information + * cdef int nrows = SCIPgetNLPRows(self._scip) # <<<<<<<<<<<<<< + * cdef SCIP_Real* coefs = malloc(nrows * sizeof(SCIP_Real)) + * + */ + __pyx_v_nrows = SCIPgetNLPRows(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":1938 + * # TODO: sparsity information + * cdef int nrows = SCIPgetNLPRows(self._scip) + * cdef SCIP_Real* coefs = malloc(nrows * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPgetLPBInvRow(self._scip, row, coefs, NULL, NULL)) + */ + __pyx_v_coefs = ((SCIP_Real *)malloc((__pyx_v_nrows * (sizeof(SCIP_Real))))); + + /* "src/pyscipopt/scip.pxi":1940 + * cdef SCIP_Real* coefs = malloc(nrows * sizeof(SCIP_Real)) + * + * PY_SCIP_CALL(SCIPgetLPBInvRow(self._scip, row, coefs, NULL, NULL)) # <<<<<<<<<<<<<< + * result = [coefs[i] for i in range(nrows)] + * free(coefs) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1940, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_row); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1940, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetLPBInvRow(__pyx_v_self->_scip, __pyx_t_3, __pyx_v_coefs, NULL, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1940, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_3 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_3 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1940, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1941 + * + * PY_SCIP_CALL(SCIPgetLPBInvRow(self._scip, row, coefs, NULL, NULL)) + * result = [coefs[i] for i in range(nrows)] # <<<<<<<<<<<<<< + * free(coefs) + * return result + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_v_nrows; + __pyx_t_6 = __pyx_t_3; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr33__pyx_v_i = __pyx_t_7; + __pyx_t_2 = PyFloat_FromDouble((__pyx_v_coefs[__pyx_9genexpr33__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1941, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1942 + * PY_SCIP_CALL(SCIPgetLPBInvRow(self._scip, row, coefs, NULL, NULL)) + * result = [coefs[i] for i in range(nrows)] + * free(coefs) # <<<<<<<<<<<<<< + * return result + * + */ + free(__pyx_v_coefs); + + /* "src/pyscipopt/scip.pxi":1943 + * result = [coefs[i] for i in range(nrows)] + * free(coefs) + * return result # <<<<<<<<<<<<<< + * + * def getLPBInvARow(self, row): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1934 + * return result + * + * def getLPBInvRow(self, row): # <<<<<<<<<<<<<< + * """gets a row from the inverse basis matrix B^-1""" + * # TODO: sparsity information + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPBInvRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1945 + * return result + * + * def getLPBInvARow(self, row): # <<<<<<<<<<<<<< + * """gets a row from B^-1 * A""" + * # TODO: sparsity information + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_207getLPBInvARow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_206getLPBInvARow, "Model.getLPBInvARow(self, row)\ngets a row from B^-1 * A"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_207getLPBInvARow = {"getLPBInvARow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_207getLPBInvARow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_206getLPBInvARow}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_207getLPBInvARow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPBInvARow (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1945, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getLPBInvARow") < 0)) __PYX_ERR(0, 1945, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getLPBInvARow", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1945, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPBInvARow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_206getLPBInvARow(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_206getLPBInvARow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_row) { + int __pyx_v_ncols; + SCIP_Real *__pyx_v_coefs; + PyObject *__pyx_v_result = NULL; + int __pyx_9genexpr34__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPBInvARow", 1); + + /* "src/pyscipopt/scip.pxi":1948 + * """gets a row from B^-1 * A""" + * # TODO: sparsity information + * cdef int ncols = SCIPgetNLPCols(self._scip) # <<<<<<<<<<<<<< + * cdef SCIP_Real* coefs = malloc(ncols * sizeof(SCIP_Real)) + * + */ + __pyx_v_ncols = SCIPgetNLPCols(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":1949 + * # TODO: sparsity information + * cdef int ncols = SCIPgetNLPCols(self._scip) + * cdef SCIP_Real* coefs = malloc(ncols * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPgetLPBInvARow(self._scip, row, NULL, coefs, NULL, NULL)) + */ + __pyx_v_coefs = ((SCIP_Real *)malloc((__pyx_v_ncols * (sizeof(SCIP_Real))))); + + /* "src/pyscipopt/scip.pxi":1951 + * cdef SCIP_Real* coefs = malloc(ncols * sizeof(SCIP_Real)) + * + * PY_SCIP_CALL(SCIPgetLPBInvARow(self._scip, row, NULL, coefs, NULL, NULL)) # <<<<<<<<<<<<<< + * result = [coefs[i] for i in range(ncols)] + * free(coefs) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_row); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1951, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetLPBInvARow(__pyx_v_self->_scip, __pyx_t_3, NULL, __pyx_v_coefs, NULL, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_3 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_3 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1952 + * + * PY_SCIP_CALL(SCIPgetLPBInvARow(self._scip, row, NULL, coefs, NULL, NULL)) + * result = [coefs[i] for i in range(ncols)] # <<<<<<<<<<<<<< + * free(coefs) + * return result + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_v_ncols; + __pyx_t_6 = __pyx_t_3; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr34__pyx_v_i = __pyx_t_7; + __pyx_t_2 = PyFloat_FromDouble((__pyx_v_coefs[__pyx_9genexpr34__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 1952, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1953 + * PY_SCIP_CALL(SCIPgetLPBInvARow(self._scip, row, NULL, coefs, NULL, NULL)) + * result = [coefs[i] for i in range(ncols)] + * free(coefs) # <<<<<<<<<<<<<< + * return result + * + */ + free(__pyx_v_coefs); + + /* "src/pyscipopt/scip.pxi":1954 + * result = [coefs[i] for i in range(ncols)] + * free(coefs) + * return result # <<<<<<<<<<<<<< + * + * def isLPSolBasic(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1945 + * return result + * + * def getLPBInvARow(self, row): # <<<<<<<<<<<<<< + * """gets a row from B^-1 * A""" + * # TODO: sparsity information + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPBInvARow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1956 + * return result + * + * def isLPSolBasic(self): # <<<<<<<<<<<<<< + * """returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis""" + * return SCIPisLPSolBasic(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_209isLPSolBasic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_208isLPSolBasic, "Model.isLPSolBasic(self)\nreturns whether the current LP solution is basic, i.e. is defined by a valid simplex basis"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_209isLPSolBasic = {"isLPSolBasic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_209isLPSolBasic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_208isLPSolBasic}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_209isLPSolBasic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isLPSolBasic (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isLPSolBasic", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isLPSolBasic", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_208isLPSolBasic(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_208isLPSolBasic(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isLPSolBasic", 1); + + /* "src/pyscipopt/scip.pxi":1958 + * def isLPSolBasic(self): + * """returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis""" + * return SCIPisLPSolBasic(self._scip) # <<<<<<<<<<<<<< + * + * #TODO: documentation!! + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPisLPSolBasic(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1956 + * return result + * + * def isLPSolBasic(self): # <<<<<<<<<<<<<< + * """returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis""" + * return SCIPisLPSolBasic(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.isLPSolBasic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1962 + * #TODO: documentation!! + * # LP Row Methods + * def createEmptyRowSepa(self, Sepa sepa, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True): # <<<<<<<<<<<<<< + * """creates and captures an LP row without any coefficients from a separator + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_211createEmptyRowSepa(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_210createEmptyRowSepa, "Model.createEmptyRowSepa(self, Sepa sepa, name=u'row', lhs=0.0, rhs=None, local=True, modifiable=False, removable=True)\ncreates and captures an LP row without any coefficients from a separator\n\n :param sepa: separator that creates the row\n :param name: name of row (Default value = \"row\")\n :param lhs: left hand side of row (Default value = 0)\n :param rhs: right hand side of row (Default value = None)\n :param local: is row only valid locally? (Default value = True)\n :param modifiable: is row modifiable during node processing (subject to column generation)? (Default value = False)\n :param removable: should the row be removed from the LP due to aging or cleanup? (Default value = True)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_211createEmptyRowSepa = {"createEmptyRowSepa", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_211createEmptyRowSepa, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_210createEmptyRowSepa}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_211createEmptyRowSepa(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_sepa = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_lhs = 0; + PyObject *__pyx_v_rhs = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_removable = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[7] = {0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createEmptyRowSepa (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sepa,&__pyx_n_s_name,&__pyx_n_s_lhs,&__pyx_n_s_rhs,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_removable,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_row)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_0_0)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sepa)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1962, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1962, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lhs); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1962, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rhs); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1962, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1962, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1962, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1962, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createEmptyRowSepa") < 0)) __PYX_ERR(0, 1962, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_sepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_lhs = values[2]; + __pyx_v_rhs = values[3]; + __pyx_v_local = values[4]; + __pyx_v_modifiable = values[5]; + __pyx_v_removable = values[6]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createEmptyRowSepa", 0, 1, 7, __pyx_nargs); __PYX_ERR(0, 1962, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createEmptyRowSepa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sepa), __pyx_ptype_9pyscipopt_4scip_Sepa, 1, "sepa", 0))) __PYX_ERR(0, 1962, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_210createEmptyRowSepa(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_sepa, __pyx_v_name, __pyx_v_lhs, __pyx_v_rhs, __pyx_v_local, __pyx_v_modifiable, __pyx_v_removable); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_210createEmptyRowSepa(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_sepa, PyObject *__pyx_v_name, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_removable) { + SCIP_ROW *__pyx_v_row; + SCIP_SEPA *__pyx_v_scip_sepa; + PyObject *__pyx_v_PyRow = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + char const *__pyx_t_9; + SCIP_Real __pyx_t_10; + SCIP_Real __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createEmptyRowSepa", 0); + __Pyx_INCREF(__pyx_v_lhs); + __Pyx_INCREF(__pyx_v_rhs); + + /* "src/pyscipopt/scip.pxi":1974 + * """ + * cdef SCIP_ROW* row + * lhs = -SCIPinfinity(self._scip) if lhs is None else lhs # <<<<<<<<<<<<<< + * rhs = SCIPinfinity(self._scip) if rhs is None else rhs + * scip_sepa = SCIPfindSepa(self._scip, str_conversion(sepa.name)) + */ + __pyx_t_2 = (__pyx_v_lhs == Py_None); + if (__pyx_t_2) { + __pyx_t_3 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_v_lhs); + __pyx_t_1 = __pyx_v_lhs; + } + __Pyx_DECREF_SET(__pyx_v_lhs, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1975 + * cdef SCIP_ROW* row + * lhs = -SCIPinfinity(self._scip) if lhs is None else lhs + * rhs = SCIPinfinity(self._scip) if rhs is None else rhs # <<<<<<<<<<<<<< + * scip_sepa = SCIPfindSepa(self._scip, str_conversion(sepa.name)) + * PY_SCIP_CALL(SCIPcreateEmptyRowSepa(self._scip, &row, scip_sepa, str_conversion(name), lhs, rhs, local, modifiable, removable)) + */ + __pyx_t_2 = (__pyx_v_rhs == Py_None); + if (__pyx_t_2) { + __pyx_t_3 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1975, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_v_rhs); + __pyx_t_1 = __pyx_v_rhs; + } + __Pyx_DECREF_SET(__pyx_v_rhs, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1976 + * lhs = -SCIPinfinity(self._scip) if lhs is None else lhs + * rhs = SCIPinfinity(self._scip) if rhs is None else rhs + * scip_sepa = SCIPfindSepa(self._scip, str_conversion(sepa.name)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateEmptyRowSepa(self._scip, &row, scip_sepa, str_conversion(name), lhs, rhs, local, modifiable, removable)) + * PyRow = Row.create(row) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_sepa->name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 1976, __pyx_L1_error) + __pyx_v_scip_sepa = SCIPfindSepa(__pyx_v_self->_scip, __pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1977 + * rhs = SCIPinfinity(self._scip) if rhs is None else rhs + * scip_sepa = SCIPfindSepa(self._scip, str_conversion(sepa.name)) + * PY_SCIP_CALL(SCIPcreateEmptyRowSepa(self._scip, &row, scip_sepa, str_conversion(name), lhs, rhs, local, modifiable, removable)) # <<<<<<<<<<<<<< + * PyRow = Row.create(row) + * return PyRow + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_name}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_9 = __Pyx_PyObject_AsString(__pyx_t_4); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_lhs); if (unlikely((__pyx_t_10 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L1_error) + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_v_rhs); if (unlikely((__pyx_t_11 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_modifiable); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1977, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateEmptyRowSepa(__pyx_v_self->_scip, (&__pyx_v_row), __pyx_v_scip_sepa, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1978 + * scip_sepa = SCIPfindSepa(self._scip, str_conversion(sepa.name)) + * PY_SCIP_CALL(SCIPcreateEmptyRowSepa(self._scip, &row, scip_sepa, str_conversion(name), lhs, rhs, local, modifiable, removable)) + * PyRow = Row.create(row) # <<<<<<<<<<<<<< + * return PyRow + * + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_3Row_create(__pyx_v_row); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyRow = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1979 + * PY_SCIP_CALL(SCIPcreateEmptyRowSepa(self._scip, &row, scip_sepa, str_conversion(name), lhs, rhs, local, modifiable, removable)) + * PyRow = Row.create(row) + * return PyRow # <<<<<<<<<<<<<< + * + * def createEmptyRowUnspec(self, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_PyRow); + __pyx_r = __pyx_v_PyRow; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1962 + * #TODO: documentation!! + * # LP Row Methods + * def createEmptyRowSepa(self, Sepa sepa, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True): # <<<<<<<<<<<<<< + * """creates and captures an LP row without any coefficients from a separator + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.createEmptyRowSepa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_PyRow); + __Pyx_XDECREF(__pyx_v_lhs); + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1981 + * return PyRow + * + * def createEmptyRowUnspec(self, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True): # <<<<<<<<<<<<<< + * """creates and captures an LP row without any coefficients from an unspecified source + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_213createEmptyRowUnspec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_212createEmptyRowUnspec, "Model.createEmptyRowUnspec(self, name=u'row', lhs=0.0, rhs=None, local=True, modifiable=False, removable=True)\ncreates and captures an LP row without any coefficients from an unspecified source\n\n :param name: name of row (Default value = \"row\")\n :param lhs: left hand side of row (Default value = 0)\n :param rhs: right hand side of row (Default value = None)\n :param local: is row only valid locally? (Default value = True)\n :param modifiable: is row modifiable during node processing (subject to column generation)? (Default value = False)\n :param removable: should the row be removed from the LP due to aging or cleanup? (Default value = True)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_213createEmptyRowUnspec = {"createEmptyRowUnspec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_213createEmptyRowUnspec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_212createEmptyRowUnspec}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_213createEmptyRowUnspec(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_lhs = 0; + PyObject *__pyx_v_rhs = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_removable = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[6] = {0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createEmptyRowUnspec (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_lhs,&__pyx_n_s_rhs,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_removable,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_row)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_0_0)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1981, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lhs); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1981, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rhs); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1981, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1981, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1981, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1981, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createEmptyRowUnspec") < 0)) __PYX_ERR(0, 1981, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_name = values[0]; + __pyx_v_lhs = values[1]; + __pyx_v_rhs = values[2]; + __pyx_v_local = values[3]; + __pyx_v_modifiable = values[4]; + __pyx_v_removable = values[5]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createEmptyRowUnspec", 0, 0, 6, __pyx_nargs); __PYX_ERR(0, 1981, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createEmptyRowUnspec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_212createEmptyRowUnspec(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_lhs, __pyx_v_rhs, __pyx_v_local, __pyx_v_modifiable, __pyx_v_removable); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_212createEmptyRowUnspec(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_lhs, PyObject *__pyx_v_rhs, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_removable) { + SCIP_ROW *__pyx_v_row; + PyObject *__pyx_v_PyRow = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + char const *__pyx_t_8; + SCIP_Real __pyx_t_9; + SCIP_Real __pyx_t_10; + SCIP_Bool __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createEmptyRowUnspec", 0); + __Pyx_INCREF(__pyx_v_lhs); + __Pyx_INCREF(__pyx_v_rhs); + + /* "src/pyscipopt/scip.pxi":1992 + * """ + * cdef SCIP_ROW* row + * lhs = -SCIPinfinity(self._scip) if lhs is None else lhs # <<<<<<<<<<<<<< + * rhs = SCIPinfinity(self._scip) if rhs is None else rhs + * PY_SCIP_CALL(SCIPcreateEmptyRowUnspec(self._scip, &row, str_conversion(name), lhs, rhs, local, modifiable, removable)) + */ + __pyx_t_2 = (__pyx_v_lhs == Py_None); + if (__pyx_t_2) { + __pyx_t_3 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1992, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_v_lhs); + __pyx_t_1 = __pyx_v_lhs; + } + __Pyx_DECREF_SET(__pyx_v_lhs, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1993 + * cdef SCIP_ROW* row + * lhs = -SCIPinfinity(self._scip) if lhs is None else lhs + * rhs = SCIPinfinity(self._scip) if rhs is None else rhs # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateEmptyRowUnspec(self._scip, &row, str_conversion(name), lhs, rhs, local, modifiable, removable)) + * PyRow = Row.create(row) + */ + __pyx_t_2 = (__pyx_v_rhs == Py_None); + if (__pyx_t_2) { + __pyx_t_3 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1993, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __Pyx_INCREF(__pyx_v_rhs); + __pyx_t_1 = __pyx_v_rhs; + } + __Pyx_DECREF_SET(__pyx_v_rhs, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1994 + * lhs = -SCIPinfinity(self._scip) if lhs is None else lhs + * rhs = SCIPinfinity(self._scip) if rhs is None else rhs + * PY_SCIP_CALL(SCIPcreateEmptyRowUnspec(self._scip, &row, str_conversion(name), lhs, rhs, local, modifiable, removable)) # <<<<<<<<<<<<<< + * PyRow = Row.create(row) + * return PyRow + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_name}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_8 = __Pyx_PyObject_AsString(__pyx_t_4); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(0, 1994, __pyx_L1_error) + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_v_lhs); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1994, __pyx_L1_error) + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_rhs); if (unlikely((__pyx_t_10 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1994, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1994, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_modifiable); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1994, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 1994, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateEmptyRowUnspec(__pyx_v_self->_scip, (&__pyx_v_row), __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1995 + * rhs = SCIPinfinity(self._scip) if rhs is None else rhs + * PY_SCIP_CALL(SCIPcreateEmptyRowUnspec(self._scip, &row, str_conversion(name), lhs, rhs, local, modifiable, removable)) + * PyRow = Row.create(row) # <<<<<<<<<<<<<< + * return PyRow + * + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_3Row_create(__pyx_v_row); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1995, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyRow = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":1996 + * PY_SCIP_CALL(SCIPcreateEmptyRowUnspec(self._scip, &row, str_conversion(name), lhs, rhs, local, modifiable, removable)) + * PyRow = Row.create(row) + * return PyRow # <<<<<<<<<<<<<< + * + * def getRowActivity(self, Row row): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_PyRow); + __pyx_r = __pyx_v_PyRow; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1981 + * return PyRow + * + * def createEmptyRowUnspec(self, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True): # <<<<<<<<<<<<<< + * """creates and captures an LP row without any coefficients from an unspecified source + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.createEmptyRowUnspec", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_PyRow); + __Pyx_XDECREF(__pyx_v_lhs); + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":1998 + * return PyRow + * + * def getRowActivity(self, Row row): # <<<<<<<<<<<<<< + * """returns the activity of a row in the last LP or pseudo solution""" + * return SCIPgetRowActivity(self._scip, row.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_215getRowActivity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_214getRowActivity, "Model.getRowActivity(self, Row row)\nreturns the activity of a row in the last LP or pseudo solution"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_215getRowActivity = {"getRowActivity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_215getRowActivity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_214getRowActivity}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_215getRowActivity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRowActivity (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1998, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getRowActivity") < 0)) __PYX_ERR(0, 1998, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getRowActivity", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1998, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowActivity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 1998, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_214getRowActivity(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_214getRowActivity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRowActivity", 1); + + /* "src/pyscipopt/scip.pxi":2000 + * def getRowActivity(self, Row row): + * """returns the activity of a row in the last LP or pseudo solution""" + * return SCIPgetRowActivity(self._scip, row.scip_row) # <<<<<<<<<<<<<< + * + * def getRowLPActivity(self, Row row): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetRowActivity(__pyx_v_self->_scip, __pyx_v_row->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":1998 + * return PyRow + * + * def getRowActivity(self, Row row): # <<<<<<<<<<<<<< + * """returns the activity of a row in the last LP or pseudo solution""" + * return SCIPgetRowActivity(self._scip, row.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowActivity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2002 + * return SCIPgetRowActivity(self._scip, row.scip_row) + * + * def getRowLPActivity(self, Row row): # <<<<<<<<<<<<<< + * """returns the activity of a row in the last LP solution""" + * return SCIPgetRowLPActivity(self._scip, row.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_217getRowLPActivity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_216getRowLPActivity, "Model.getRowLPActivity(self, Row row)\nreturns the activity of a row in the last LP solution"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_217getRowLPActivity = {"getRowLPActivity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_217getRowLPActivity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_216getRowLPActivity}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_217getRowLPActivity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRowLPActivity (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2002, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getRowLPActivity") < 0)) __PYX_ERR(0, 2002, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getRowLPActivity", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2002, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowLPActivity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 2002, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_216getRowLPActivity(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_216getRowLPActivity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRowLPActivity", 1); + + /* "src/pyscipopt/scip.pxi":2004 + * def getRowLPActivity(self, Row row): + * """returns the activity of a row in the last LP solution""" + * return SCIPgetRowLPActivity(self._scip, row.scip_row) # <<<<<<<<<<<<<< + * + * # TODO: do we need this? (also do we need release var??) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetRowLPActivity(__pyx_v_self->_scip, __pyx_v_row->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2004, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2002 + * return SCIPgetRowActivity(self._scip, row.scip_row) + * + * def getRowLPActivity(self, Row row): # <<<<<<<<<<<<<< + * """returns the activity of a row in the last LP solution""" + * return SCIPgetRowLPActivity(self._scip, row.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowLPActivity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2007 + * + * # TODO: do we need this? (also do we need release var??) + * def releaseRow(self, Row row not None): # <<<<<<<<<<<<<< + * """decreases usage counter of LP row, and frees memory if necessary""" + * PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_219releaseRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_218releaseRow, "Model.releaseRow(self, Row row)\ndecreases usage counter of LP row, and frees memory if necessary"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_219releaseRow = {"releaseRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_219releaseRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_218releaseRow}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_219releaseRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("releaseRow (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2007, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "releaseRow") < 0)) __PYX_ERR(0, 2007, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("releaseRow", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2007, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.releaseRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 0, "row", 0))) __PYX_ERR(0, 2007, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_218releaseRow(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_218releaseRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("releaseRow", 1); + + /* "src/pyscipopt/scip.pxi":2009 + * def releaseRow(self, Row row not None): + * """decreases usage counter of LP row, and frees memory if necessary""" + * PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row)) # <<<<<<<<<<<<<< + * + * def cacheRowExtensions(self, Row row not None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseRow(__pyx_v_self->_scip, (&__pyx_v_row->scip_row))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2009, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2007 + * + * # TODO: do we need this? (also do we need release var??) + * def releaseRow(self, Row row not None): # <<<<<<<<<<<<<< + * """decreases usage counter of LP row, and frees memory if necessary""" + * PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.releaseRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2011 + * PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row)) + * + * def cacheRowExtensions(self, Row row not None): # <<<<<<<<<<<<<< + * """informs row, that all subsequent additions of variables to the row should be cached and not directly applied; + * after all additions were applied, flushRowExtensions() must be called; + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_221cacheRowExtensions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_220cacheRowExtensions, "Model.cacheRowExtensions(self, Row row)\ninforms row, that all subsequent additions of variables to the row should be cached and not directly applied;\n after all additions were applied, flushRowExtensions() must be called;\n while the caching of row extensions is activated, information methods of the row give invalid results;\n caching should be used, if a row is build with addVarToRow() calls variable by variable to increase the performance"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_221cacheRowExtensions = {"cacheRowExtensions", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_221cacheRowExtensions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_220cacheRowExtensions}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_221cacheRowExtensions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("cacheRowExtensions (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2011, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "cacheRowExtensions") < 0)) __PYX_ERR(0, 2011, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("cacheRowExtensions", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2011, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.cacheRowExtensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 0, "row", 0))) __PYX_ERR(0, 2011, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_220cacheRowExtensions(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_220cacheRowExtensions(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("cacheRowExtensions", 1); + + /* "src/pyscipopt/scip.pxi":2016 + * while the caching of row extensions is activated, information methods of the row give invalid results; + * caching should be used, if a row is build with addVarToRow() calls variable by variable to increase the performance""" + * PY_SCIP_CALL(SCIPcacheRowExtensions(self._scip, row.scip_row)) # <<<<<<<<<<<<<< + * + * def flushRowExtensions(self, Row row not None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcacheRowExtensions(__pyx_v_self->_scip, __pyx_v_row->scip_row)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2011 + * PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row)) + * + * def cacheRowExtensions(self, Row row not None): # <<<<<<<<<<<<<< + * """informs row, that all subsequent additions of variables to the row should be cached and not directly applied; + * after all additions were applied, flushRowExtensions() must be called; + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.cacheRowExtensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2018 + * PY_SCIP_CALL(SCIPcacheRowExtensions(self._scip, row.scip_row)) + * + * def flushRowExtensions(self, Row row not None): # <<<<<<<<<<<<<< + * """flushes all cached row extensions after a call of cacheRowExtensions() and merges coefficients with equal columns into a single coefficient""" + * PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_223flushRowExtensions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_222flushRowExtensions, "Model.flushRowExtensions(self, Row row)\nflushes all cached row extensions after a call of cacheRowExtensions() and merges coefficients with equal columns into a single coefficient"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_223flushRowExtensions = {"flushRowExtensions", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_223flushRowExtensions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_222flushRowExtensions}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_223flushRowExtensions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("flushRowExtensions (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2018, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "flushRowExtensions") < 0)) __PYX_ERR(0, 2018, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("flushRowExtensions", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2018, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.flushRowExtensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 0, "row", 0))) __PYX_ERR(0, 2018, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_222flushRowExtensions(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_222flushRowExtensions(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("flushRowExtensions", 1); + + /* "src/pyscipopt/scip.pxi":2020 + * def flushRowExtensions(self, Row row not None): + * """flushes all cached row extensions after a call of cacheRowExtensions() and merges coefficients with equal columns into a single coefficient""" + * PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row)) # <<<<<<<<<<<<<< + * + * def addVarToRow(self, Row row not None, Variable var not None, value): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2020, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPflushRowExtensions(__pyx_v_self->_scip, __pyx_v_row->scip_row)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2020, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2020, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2018 + * PY_SCIP_CALL(SCIPcacheRowExtensions(self._scip, row.scip_row)) + * + * def flushRowExtensions(self, Row row not None): # <<<<<<<<<<<<<< + * """flushes all cached row extensions after a call of cacheRowExtensions() and merges coefficients with equal columns into a single coefficient""" + * PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.flushRowExtensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2022 + * PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row)) + * + * def addVarToRow(self, Row row not None, Variable var not None, value): # <<<<<<<<<<<<<< + * """resolves variable to columns and adds them with the coefficient to the row""" + * PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_225addVarToRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_224addVarToRow, "Model.addVarToRow(self, Row row, Variable var, value)\nresolves variable to columns and adds them with the coefficient to the row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_225addVarToRow = {"addVarToRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_225addVarToRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_224addVarToRow}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_225addVarToRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addVarToRow (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_var,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2022, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2022, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addVarToRow", 1, 3, 3, 1); __PYX_ERR(0, 2022, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2022, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addVarToRow", 1, 3, 3, 2); __PYX_ERR(0, 2022, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addVarToRow") < 0)) __PYX_ERR(0, 2022, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_value = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addVarToRow", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2022, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addVarToRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 0, "row", 0))) __PYX_ERR(0, 2022, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 0, "var", 0))) __PYX_ERR(0, 2022, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_224addVarToRow(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row, __pyx_v_var, __pyx_v_value); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_224addVarToRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addVarToRow", 1); + + /* "src/pyscipopt/scip.pxi":2024 + * def addVarToRow(self, Row row not None, Variable var not None, value): + * """resolves variable to columns and adds them with the coefficient to the row""" + * PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value)) # <<<<<<<<<<<<<< + * + * def printRow(self, Row row not None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2024, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVarToRow(__pyx_v_self->_scip, __pyx_v_row->scip_row, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2022 + * PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row)) + * + * def addVarToRow(self, Row row not None, Variable var not None, value): # <<<<<<<<<<<<<< + * """resolves variable to columns and adds them with the coefficient to the row""" + * PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addVarToRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2026 + * PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value)) + * + * def printRow(self, Row row not None): # <<<<<<<<<<<<<< + * """Prints row.""" + * PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_227printRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_226printRow, "Model.printRow(self, Row row)\nPrints row."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_227printRow = {"printRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_227printRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_226printRow}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_227printRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("printRow (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2026, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "printRow") < 0)) __PYX_ERR(0, 2026, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("printRow", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2026, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.printRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 0, "row", 0))) __PYX_ERR(0, 2026, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_226printRow(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_226printRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("printRow", 1); + + /* "src/pyscipopt/scip.pxi":2028 + * def printRow(self, Row row not None): + * """Prints row.""" + * PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL)) # <<<<<<<<<<<<<< + * + * def getRowNumIntCols(self, Row row): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintRow(__pyx_v_self->_scip, __pyx_v_row->scip_row, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2026 + * PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value)) + * + * def printRow(self, Row row not None): # <<<<<<<<<<<<<< + * """Prints row.""" + * PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.printRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2030 + * PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL)) + * + * def getRowNumIntCols(self, Row row): # <<<<<<<<<<<<<< + * """Returns number of intergal columns in the row""" + * return SCIPgetRowNumIntCols(self._scip, row.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_229getRowNumIntCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_228getRowNumIntCols, "Model.getRowNumIntCols(self, Row row)\nReturns number of intergal columns in the row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_229getRowNumIntCols = {"getRowNumIntCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_229getRowNumIntCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_228getRowNumIntCols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_229getRowNumIntCols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRowNumIntCols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2030, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getRowNumIntCols") < 0)) __PYX_ERR(0, 2030, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getRowNumIntCols", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2030, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowNumIntCols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 2030, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_228getRowNumIntCols(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_228getRowNumIntCols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRowNumIntCols", 1); + + /* "src/pyscipopt/scip.pxi":2032 + * def getRowNumIntCols(self, Row row): + * """Returns number of intergal columns in the row""" + * return SCIPgetRowNumIntCols(self._scip, row.scip_row) # <<<<<<<<<<<<<< + * + * def getRowObjParallelism(self, Row row): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetRowNumIntCols(__pyx_v_self->_scip, __pyx_v_row->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2032, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2030 + * PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL)) + * + * def getRowNumIntCols(self, Row row): # <<<<<<<<<<<<<< + * """Returns number of intergal columns in the row""" + * return SCIPgetRowNumIntCols(self._scip, row.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowNumIntCols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2034 + * return SCIPgetRowNumIntCols(self._scip, row.scip_row) + * + * def getRowObjParallelism(self, Row row): # <<<<<<<<<<<<<< + * """Returns 1 if the row is parallel, and 0 if orthogonal""" + * return SCIPgetRowObjParallelism(self._scip, row.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_231getRowObjParallelism(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_230getRowObjParallelism, "Model.getRowObjParallelism(self, Row row)\nReturns 1 if the row is parallel, and 0 if orthogonal"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_231getRowObjParallelism = {"getRowObjParallelism", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_231getRowObjParallelism, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_230getRowObjParallelism}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_231getRowObjParallelism(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRowObjParallelism (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2034, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getRowObjParallelism") < 0)) __PYX_ERR(0, 2034, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getRowObjParallelism", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2034, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowObjParallelism", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 2034, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_230getRowObjParallelism(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_230getRowObjParallelism(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRowObjParallelism", 1); + + /* "src/pyscipopt/scip.pxi":2036 + * def getRowObjParallelism(self, Row row): + * """Returns 1 if the row is parallel, and 0 if orthogonal""" + * return SCIPgetRowObjParallelism(self._scip, row.scip_row) # <<<<<<<<<<<<<< + * + * def getRowParallelism(self, Row row1, Row row2, orthofunc=101): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetRowObjParallelism(__pyx_v_self->_scip, __pyx_v_row->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2036, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2034 + * return SCIPgetRowNumIntCols(self._scip, row.scip_row) + * + * def getRowObjParallelism(self, Row row): # <<<<<<<<<<<<<< + * """Returns 1 if the row is parallel, and 0 if orthogonal""" + * return SCIPgetRowObjParallelism(self._scip, row.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowObjParallelism", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2038 + * return SCIPgetRowObjParallelism(self._scip, row.scip_row) + * + * def getRowParallelism(self, Row row1, Row row2, orthofunc=101): # <<<<<<<<<<<<<< + * """Returns the degree of parallelism between hyplerplanes. 1 if perfectly parallel, 0 if orthognal. + * 101 in this case is an 'e' (euclidean) in ASCII. The other accpetable input is 100 (d for discrete).""" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_233getRowParallelism(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_232getRowParallelism, "Model.getRowParallelism(self, Row row1, Row row2, orthofunc=101)\nReturns the degree of parallelism between hyplerplanes. 1 if perfectly parallel, 0 if orthognal.\n 101 in this case is an 'e' (euclidean) in ASCII. The other accpetable input is 100 (d for discrete)."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_233getRowParallelism = {"getRowParallelism", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_233getRowParallelism, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_232getRowParallelism}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_233getRowParallelism(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row1 = 0; + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row2 = 0; + PyObject *__pyx_v_orthofunc = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRowParallelism (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row1,&__pyx_n_s_row2,&__pyx_n_s_orthofunc,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_101)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row1)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2038, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row2)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2038, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("getRowParallelism", 0, 2, 3, 1); __PYX_ERR(0, 2038, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_orthofunc); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2038, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getRowParallelism") < 0)) __PYX_ERR(0, 2038, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_row1 = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_row2 = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[1]); + __pyx_v_orthofunc = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getRowParallelism", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 2038, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowParallelism", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row1), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row1", 0))) __PYX_ERR(0, 2038, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row2), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row2", 0))) __PYX_ERR(0, 2038, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_232getRowParallelism(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row1, __pyx_v_row2, __pyx_v_orthofunc); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_232getRowParallelism(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row1, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row2, PyObject *__pyx_v_orthofunc) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRowParallelism", 1); + + /* "src/pyscipopt/scip.pxi":2041 + * """Returns the degree of parallelism between hyplerplanes. 1 if perfectly parallel, 0 if orthognal. + * 101 in this case is an 'e' (euclidean) in ASCII. The other accpetable input is 100 (d for discrete).""" + * return SCIProwGetParallelism(row1.scip_row, row2.scip_row, orthofunc) # <<<<<<<<<<<<<< + * + * def getRowDualSol(self, Row row): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_As_char(__pyx_v_orthofunc); if (unlikely((__pyx_t_1 == (char)-1) && PyErr_Occurred())) __PYX_ERR(0, 2041, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(SCIProwGetParallelism(__pyx_v_row1->scip_row, __pyx_v_row2->scip_row, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2041, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2038 + * return SCIPgetRowObjParallelism(self._scip, row.scip_row) + * + * def getRowParallelism(self, Row row1, Row row2, orthofunc=101): # <<<<<<<<<<<<<< + * """Returns the degree of parallelism between hyplerplanes. 1 if perfectly parallel, 0 if orthognal. + * 101 in this case is an 'e' (euclidean) in ASCII. The other accpetable input is 100 (d for discrete).""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowParallelism", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2043 + * return SCIProwGetParallelism(row1.scip_row, row2.scip_row, orthofunc) + * + * def getRowDualSol(self, Row row): # <<<<<<<<<<<<<< + * """Gets the dual LP solution of a row""" + * return SCIProwGetDualsol(row.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_235getRowDualSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_234getRowDualSol, "Model.getRowDualSol(self, Row row)\nGets the dual LP solution of a row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_235getRowDualSol = {"getRowDualSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_235getRowDualSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_234getRowDualSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_235getRowDualSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRowDualSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2043, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getRowDualSol") < 0)) __PYX_ERR(0, 2043, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getRowDualSol", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2043, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowDualSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 2043, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_234getRowDualSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_234getRowDualSol(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRowDualSol", 1); + + /* "src/pyscipopt/scip.pxi":2045 + * def getRowDualSol(self, Row row): + * """Gets the dual LP solution of a row""" + * return SCIProwGetDualsol(row.scip_row) # <<<<<<<<<<<<<< + * + * # Cutting Plane Methods + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIProwGetDualsol(__pyx_v_row->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2043 + * return SCIProwGetParallelism(row1.scip_row, row2.scip_row, orthofunc) + * + * def getRowDualSol(self, Row row): # <<<<<<<<<<<<<< + * """Gets the dual LP solution of a row""" + * return SCIProwGetDualsol(row.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowDualSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2048 + * + * # Cutting Plane Methods + * def addPoolCut(self, Row row not None): # <<<<<<<<<<<<<< + * """if not already existing, adds row to global cut pool""" + * PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_237addPoolCut(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_236addPoolCut, "Model.addPoolCut(self, Row row)\nif not already existing, adds row to global cut pool"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_237addPoolCut = {"addPoolCut", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_237addPoolCut, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_236addPoolCut}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_237addPoolCut(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addPoolCut (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2048, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addPoolCut") < 0)) __PYX_ERR(0, 2048, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addPoolCut", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2048, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addPoolCut", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 0, "row", 0))) __PYX_ERR(0, 2048, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_236addPoolCut(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_236addPoolCut(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addPoolCut", 1); + + /* "src/pyscipopt/scip.pxi":2050 + * def addPoolCut(self, Row row not None): + * """if not already existing, adds row to global cut pool""" + * PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row)) # <<<<<<<<<<<<<< + * + * def getCutEfficacy(self, Row cut not None, Solution sol = None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddPoolCut(__pyx_v_self->_scip, __pyx_v_row->scip_row)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2050, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2048 + * + * # Cutting Plane Methods + * def addPoolCut(self, Row row not None): # <<<<<<<<<<<<<< + * """if not already existing, adds row to global cut pool""" + * PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.addPoolCut", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2052 + * PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row)) + * + * def getCutEfficacy(self, Row cut not None, Solution sol = None): # <<<<<<<<<<<<<< + * """returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm""" + * return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_239getCutEfficacy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_238getCutEfficacy, "Model.getCutEfficacy(self, Row cut, Solution sol=None)\nreturns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_239getCutEfficacy = {"getCutEfficacy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_239getCutEfficacy, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_238getCutEfficacy}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_239getCutEfficacy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getCutEfficacy (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cut,&__pyx_n_s_sol,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cut)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2052, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2052, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getCutEfficacy") < 0)) __PYX_ERR(0, 2052, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cut = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getCutEfficacy", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2052, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getCutEfficacy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cut), __pyx_ptype_9pyscipopt_4scip_Row, 0, "cut", 0))) __PYX_ERR(0, 2052, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 2052, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_238getCutEfficacy(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cut, __pyx_v_sol); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_238getCutEfficacy(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + void *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getCutEfficacy", 1); + + /* "src/pyscipopt/scip.pxi":2054 + * def getCutEfficacy(self, Row cut not None, Solution sol = None): + * """returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm""" + * return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row) # <<<<<<<<<<<<<< + * + * def isCutEfficacious(self, Row cut not None, Solution sol = None): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (((PyObject *)__pyx_v_sol) == Py_None); + if (__pyx_t_2) { + __pyx_t_1 = NULL; + } else { + __pyx_t_1 = __pyx_v_sol->sol; + } + __pyx_t_3 = PyFloat_FromDouble(SCIPgetCutEfficacy(__pyx_v_self->_scip, __pyx_t_1, __pyx_v_cut->scip_row)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2052 + * PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row)) + * + * def getCutEfficacy(self, Row cut not None, Solution sol = None): # <<<<<<<<<<<<<< + * """returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm""" + * return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.getCutEfficacy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2056 + * return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + * + * def isCutEfficacious(self, Row cut not None, Solution sol = None): # <<<<<<<<<<<<<< + * """ returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy""" + * return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_241isCutEfficacious(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_240isCutEfficacious, "Model.isCutEfficacious(self, Row cut, Solution sol=None)\n returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_241isCutEfficacious = {"isCutEfficacious", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_241isCutEfficacious, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_240isCutEfficacious}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_241isCutEfficacious(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isCutEfficacious (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cut,&__pyx_n_s_sol,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cut)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2056, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2056, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "isCutEfficacious") < 0)) __PYX_ERR(0, 2056, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cut = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("isCutEfficacious", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2056, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.isCutEfficacious", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cut), __pyx_ptype_9pyscipopt_4scip_Row, 0, "cut", 0))) __PYX_ERR(0, 2056, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 2056, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_240isCutEfficacious(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cut, __pyx_v_sol); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_240isCutEfficacious(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + void *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isCutEfficacious", 1); + + /* "src/pyscipopt/scip.pxi":2058 + * def isCutEfficacious(self, Row cut not None, Solution sol = None): + * """ returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy""" + * return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row) # <<<<<<<<<<<<<< + * + * def getCutLPSolCutoffDistance(self, Row cut not None, Solution sol not None): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (((PyObject *)__pyx_v_sol) == Py_None); + if (__pyx_t_2) { + __pyx_t_1 = NULL; + } else { + __pyx_t_1 = __pyx_v_sol->sol; + } + __pyx_t_3 = __Pyx_PyBool_FromLong(SCIPisCutEfficacious(__pyx_v_self->_scip, __pyx_t_1, __pyx_v_cut->scip_row)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2058, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2056 + * return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + * + * def isCutEfficacious(self, Row cut not None, Solution sol = None): # <<<<<<<<<<<<<< + * """ returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy""" + * return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.isCutEfficacious", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2060 + * return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + * + * def getCutLPSolCutoffDistance(self, Row cut not None, Solution sol not None): # <<<<<<<<<<<<<< + * """ returns row's cutoff distance in the direction of the given primal solution""" + * return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_243getCutLPSolCutoffDistance(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_242getCutLPSolCutoffDistance, "Model.getCutLPSolCutoffDistance(self, Row cut, Solution sol)\n returns row's cutoff distance in the direction of the given primal solution"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_243getCutLPSolCutoffDistance = {"getCutLPSolCutoffDistance", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_243getCutLPSolCutoffDistance, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_242getCutLPSolCutoffDistance}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_243getCutLPSolCutoffDistance(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getCutLPSolCutoffDistance (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cut,&__pyx_n_s_sol,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cut)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2060, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2060, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("getCutLPSolCutoffDistance", 1, 2, 2, 1); __PYX_ERR(0, 2060, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getCutLPSolCutoffDistance") < 0)) __PYX_ERR(0, 2060, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cut = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getCutLPSolCutoffDistance", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2060, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getCutLPSolCutoffDistance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cut), __pyx_ptype_9pyscipopt_4scip_Row, 0, "cut", 0))) __PYX_ERR(0, 2060, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 0, "sol", 0))) __PYX_ERR(0, 2060, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_242getCutLPSolCutoffDistance(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cut, __pyx_v_sol); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_242getCutLPSolCutoffDistance(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getCutLPSolCutoffDistance", 1); + + /* "src/pyscipopt/scip.pxi":2062 + * def getCutLPSolCutoffDistance(self, Row cut not None, Solution sol not None): + * """ returns row's cutoff distance in the direction of the given primal solution""" + * return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row) # <<<<<<<<<<<<<< + * + * def addCut(self, Row cut not None, forcecut = False): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetCutLPSolCutoffDistance(__pyx_v_self->_scip, __pyx_v_sol->sol, __pyx_v_cut->scip_row)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2060 + * return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + * + * def getCutLPSolCutoffDistance(self, Row cut not None, Solution sol not None): # <<<<<<<<<<<<<< + * """ returns row's cutoff distance in the direction of the given primal solution""" + * return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getCutLPSolCutoffDistance", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2064 + * return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row) + * + * def addCut(self, Row cut not None, forcecut = False): # <<<<<<<<<<<<<< + * """adds cut to separation storage and returns whether cut has been detected to be infeasible for local bounds""" + * cdef SCIP_Bool infeasible + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_245addCut(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_244addCut, "Model.addCut(self, Row cut, forcecut=False)\nadds cut to separation storage and returns whether cut has been detected to be infeasible for local bounds"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_245addCut = {"addCut", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_245addCut, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_244addCut}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_245addCut(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut = 0; + PyObject *__pyx_v_forcecut = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addCut (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cut,&__pyx_n_s_forcecut,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cut)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2064, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_forcecut); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2064, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addCut") < 0)) __PYX_ERR(0, 2064, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cut = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_forcecut = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addCut", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2064, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addCut", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cut), __pyx_ptype_9pyscipopt_4scip_Row, 0, "cut", 0))) __PYX_ERR(0, 2064, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_244addCut(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cut, __pyx_v_forcecut); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_244addCut(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_cut, PyObject *__pyx_v_forcecut) { + SCIP_Bool __pyx_v_infeasible; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Bool __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addCut", 1); + + /* "src/pyscipopt/scip.pxi":2067 + * """adds cut to separation storage and returns whether cut has been detected to be infeasible for local bounds""" + * cdef SCIP_Bool infeasible + * PY_SCIP_CALL(SCIPaddRow(self._scip, cut.scip_row, forcecut, &infeasible)) # <<<<<<<<<<<<<< + * return infeasible + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2067, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_forcecut); if (unlikely((__pyx_t_3 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2067, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddRow(__pyx_v_self->_scip, __pyx_v_cut->scip_row, __pyx_t_3, (&__pyx_v_infeasible))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2067, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2067, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2068 + * cdef SCIP_Bool infeasible + * PY_SCIP_CALL(SCIPaddRow(self._scip, cut.scip_row, forcecut, &infeasible)) + * return infeasible # <<<<<<<<<<<<<< + * + * def getNCuts(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_infeasible); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2064 + * return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row) + * + * def addCut(self, Row cut not None, forcecut = False): # <<<<<<<<<<<<<< + * """adds cut to separation storage and returns whether cut has been detected to be infeasible for local bounds""" + * cdef SCIP_Bool infeasible + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addCut", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2070 + * return infeasible + * + * def getNCuts(self): # <<<<<<<<<<<<<< + * """Retrieve total number of cuts in storage""" + * return SCIPgetNCuts(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_247getNCuts(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_246getNCuts, "Model.getNCuts(self)\nRetrieve total number of cuts in storage"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_247getNCuts = {"getNCuts", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_247getNCuts, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_246getNCuts}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_247getNCuts(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNCuts (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNCuts", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNCuts", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_246getNCuts(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_246getNCuts(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNCuts", 1); + + /* "src/pyscipopt/scip.pxi":2072 + * def getNCuts(self): + * """Retrieve total number of cuts in storage""" + * return SCIPgetNCuts(self._scip) # <<<<<<<<<<<<<< + * + * def getNCutsApplied(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNCuts(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2072, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2070 + * return infeasible + * + * def getNCuts(self): # <<<<<<<<<<<<<< + * """Retrieve total number of cuts in storage""" + * return SCIPgetNCuts(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNCuts", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2074 + * return SCIPgetNCuts(self._scip) + * + * def getNCutsApplied(self): # <<<<<<<<<<<<<< + * """Retrieve number of currently applied cuts""" + * return SCIPgetNCutsApplied(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_249getNCutsApplied(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_248getNCutsApplied, "Model.getNCutsApplied(self)\nRetrieve number of currently applied cuts"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_249getNCutsApplied = {"getNCutsApplied", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_249getNCutsApplied, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_248getNCutsApplied}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_249getNCutsApplied(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNCutsApplied (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNCutsApplied", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNCutsApplied", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_248getNCutsApplied(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_248getNCutsApplied(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNCutsApplied", 1); + + /* "src/pyscipopt/scip.pxi":2076 + * def getNCutsApplied(self): + * """Retrieve number of currently applied cuts""" + * return SCIPgetNCutsApplied(self._scip) # <<<<<<<<<<<<<< + * + * def getNSepaRounds(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNCutsApplied(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2074 + * return SCIPgetNCuts(self._scip) + * + * def getNCutsApplied(self): # <<<<<<<<<<<<<< + * """Retrieve number of currently applied cuts""" + * return SCIPgetNCutsApplied(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNCutsApplied", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2078 + * return SCIPgetNCutsApplied(self._scip) + * + * def getNSepaRounds(self): # <<<<<<<<<<<<<< + * """Retrieve the number of separation rounds that have been performed + * at the current node""" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_251getNSepaRounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_250getNSepaRounds, "Model.getNSepaRounds(self)\nRetrieve the number of separation rounds that have been performed\n at the current node"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_251getNSepaRounds = {"getNSepaRounds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_251getNSepaRounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_250getNSepaRounds}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_251getNSepaRounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNSepaRounds (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNSepaRounds", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNSepaRounds", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_250getNSepaRounds(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_250getNSepaRounds(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNSepaRounds", 1); + + /* "src/pyscipopt/scip.pxi":2081 + * """Retrieve the number of separation rounds that have been performed + * at the current node""" + * return SCIPgetNSepaRounds(self._scip) # <<<<<<<<<<<<<< + * + * def separateSol(self, Solution sol = None, pretendroot = False, allowlocal = True, onlydelayed = False): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNSepaRounds(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2081, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2078 + * return SCIPgetNCutsApplied(self._scip) + * + * def getNSepaRounds(self): # <<<<<<<<<<<<<< + * """Retrieve the number of separation rounds that have been performed + * at the current node""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNSepaRounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2083 + * return SCIPgetNSepaRounds(self._scip) + * + * def separateSol(self, Solution sol = None, pretendroot = False, allowlocal = True, onlydelayed = False): # <<<<<<<<<<<<<< + * """separates the given primal solution or the current LP solution by calling the separators and constraint handlers' + * separation methods; + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_253separateSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_252separateSol, "Model.separateSol(self, Solution sol=None, pretendroot=False, allowlocal=True, onlydelayed=False)\nseparates the given primal solution or the current LP solution by calling the separators and constraint handlers'\n separation methods;\n the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and\n SCIPgetNCuts();\n after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the\n separation storage;\n it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts\n afterwards\n :param Solution sol: solution to separate, None to use current lp solution (Default value = None)\n :param pretendroot: should the cut separators be called as if we are at the root node? (Default value = \"False\")\n :param allowlocal: should the separator be asked to separate local cuts (Default value = True)\n :param onlydelayed: should only separators be called that were delayed in the previous round? (Default value = False)\n returns\n delayed -- whether a separator was delayed\n cutoff -- whether the node can be cut off\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_253separateSol = {"separateSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_253separateSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_252separateSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_253separateSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + PyObject *__pyx_v_pretendroot = 0; + PyObject *__pyx_v_allowlocal = 0; + PyObject *__pyx_v_onlydelayed = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("separateSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sol,&__pyx_n_s_pretendroot,&__pyx_n_s_allowlocal,&__pyx_n_s_onlydelayed,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2083, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pretendroot); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2083, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_allowlocal); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2083, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_onlydelayed); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2083, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "separateSol") < 0)) __PYX_ERR(0, 2083, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_pretendroot = values[1]; + __pyx_v_allowlocal = values[2]; + __pyx_v_onlydelayed = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("separateSol", 0, 0, 4, __pyx_nargs); __PYX_ERR(0, 2083, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.separateSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 2083, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_252separateSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_sol, __pyx_v_pretendroot, __pyx_v_allowlocal, __pyx_v_onlydelayed); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_252separateSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol, PyObject *__pyx_v_pretendroot, PyObject *__pyx_v_allowlocal, PyObject *__pyx_v_onlydelayed) { + SCIP_Bool __pyx_v_delayed; + SCIP_Bool __pyx_v_cutoff; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + void *__pyx_t_3; + int __pyx_t_4; + SCIP_Bool __pyx_t_5; + SCIP_Bool __pyx_t_6; + SCIP_Bool __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("separateSol", 1); + + /* "src/pyscipopt/scip.pxi":2103 + * cdef SCIP_Bool cutoff + * + * PY_SCIP_CALL( SCIPseparateSol(self._scip, NULL if sol is None else sol.sol, pretendroot, allowlocal, onlydelayed, &delayed, &cutoff) ) # <<<<<<<<<<<<<< + * return delayed, cutoff + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (((PyObject *)__pyx_v_sol) == Py_None); + if (__pyx_t_4) { + __pyx_t_3 = NULL; + } else { + __pyx_t_3 = __pyx_v_sol->sol; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_pretendroot); if (unlikely((__pyx_t_5 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2103, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_allowlocal); if (unlikely((__pyx_t_6 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2103, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_onlydelayed); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2103, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPseparateSol(__pyx_v_self->_scip, __pyx_t_3, __pyx_t_5, __pyx_t_6, __pyx_t_7, (&__pyx_v_delayed), (&__pyx_v_cutoff))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2104 + * + * PY_SCIP_CALL( SCIPseparateSol(self._scip, NULL if sol is None else sol.sol, pretendroot, allowlocal, onlydelayed, &delayed, &cutoff) ) + * return delayed, cutoff # <<<<<<<<<<<<<< + * + * def _createConsLinear(self, ExprCons lincons, **kwargs): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_delayed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_cutoff); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1)) __PYX_ERR(0, 2104, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_2)) __PYX_ERR(0, 2104, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_8; + __pyx_t_8 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2083 + * return SCIPgetNSepaRounds(self._scip) + * + * def separateSol(self, Solution sol = None, pretendroot = False, allowlocal = True, onlydelayed = False): # <<<<<<<<<<<<<< + * """separates the given primal solution or the current LP solution by calling the separators and constraint handlers' + * separation methods; + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.separateSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2106 + * return delayed, cutoff + * + * def _createConsLinear(self, ExprCons lincons, **kwargs): # <<<<<<<<<<<<<< + * assert isinstance(lincons, ExprCons), "given constraint is not ExprCons but %s" % lincons.__class__.__name__ + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_255_createConsLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_254_createConsLinear, "Model._createConsLinear(self, ExprCons lincons, **kwargs)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_255_createConsLinear = {"_createConsLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_255_createConsLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_254_createConsLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_255_createConsLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_lincons = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_createConsLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lincons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lincons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2106, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, kwd_pos_args, "_createConsLinear") < 0)) __PYX_ERR(0, 2106, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_lincons = ((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_createConsLinear", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2106, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("pyscipopt.scip.Model._createConsLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_lincons), __pyx_ptype_9pyscipopt_4scip_ExprCons, 1, "lincons", 0))) __PYX_ERR(0, 2106, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_254_createConsLinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_lincons, __pyx_v_kwargs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_DECREF(__pyx_v_kwargs); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_254_createConsLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_lincons, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_v_terms = NULL; + SCIP_CONS *__pyx_v_scip_cons; + int __pyx_v_nvars; + SCIP_VAR **__pyx_v_vars_array; + SCIP_Real *__pyx_v_coeffs_array; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_key = NULL; + PyObject *__pyx_v_coeff = NULL; + PyObject *__pyx_v_PyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + Py_ssize_t __pyx_t_10; + SCIP_Real __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + char *__pyx_t_14; + SCIP_Real __pyx_t_15; + SCIP_Bool __pyx_t_16; + SCIP_Bool __pyx_t_17; + SCIP_Bool __pyx_t_18; + SCIP_Bool __pyx_t_19; + SCIP_Bool __pyx_t_20; + SCIP_Bool __pyx_t_21; + SCIP_Bool __pyx_t_22; + SCIP_Bool __pyx_t_23; + SCIP_Bool __pyx_t_24; + SCIP_Bool __pyx_t_25; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_createConsLinear", 1); + + /* "src/pyscipopt/scip.pxi":2107 + * + * def _createConsLinear(self, ExprCons lincons, **kwargs): + * assert isinstance(lincons, ExprCons), "given constraint is not ExprCons but %s" % lincons.__class__.__name__ # <<<<<<<<<<<<<< + * + * assert lincons.expr.degree() <= 1, "given constraint is not linear, degree == %d" % lincons.expr.degree() + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_lincons), __pyx_ptype_9pyscipopt_4scip_ExprCons); + if (unlikely(!__pyx_t_1)) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_lincons), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_given_constraint_is_not_ExprCons, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_2, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2107, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2107, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2109 + * assert isinstance(lincons, ExprCons), "given constraint is not ExprCons but %s" % lincons.__class__.__name__ + * + * assert lincons.expr.degree() <= 1, "given constraint is not linear, degree == %d" % lincons.expr.degree() # <<<<<<<<<<<<<< + * terms = lincons.expr.terms + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_lincons->expr, __pyx_n_s_degree); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_int_1, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_lincons->expr, __pyx_n_s_degree); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_given_constraint_is_not_linear_d, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_2, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2109, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2109, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2110 + * + * assert lincons.expr.degree() <= 1, "given constraint is not linear, degree == %d" % lincons.expr.degree() + * terms = lincons.expr.terms # <<<<<<<<<<<<<< + * + * cdef SCIP_CONS* scip_cons + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_lincons->expr, __pyx_n_s_terms); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_terms = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2114 + * cdef SCIP_CONS* scip_cons + * + * cdef int nvars = len(terms.items()) # <<<<<<<<<<<<<< + * + * vars_array = malloc(nvars * sizeof(SCIP_VAR*)) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_terms, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_6 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2114, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_nvars = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":2116 + * cdef int nvars = len(terms.items()) + * + * vars_array = malloc(nvars * sizeof(SCIP_VAR*)) # <<<<<<<<<<<<<< + * coeffs_array = malloc(nvars * sizeof(SCIP_Real)) + * + */ + __pyx_v_vars_array = ((SCIP_VAR **)malloc((__pyx_v_nvars * (sizeof(SCIP_VAR *))))); + + /* "src/pyscipopt/scip.pxi":2117 + * + * vars_array = malloc(nvars * sizeof(SCIP_VAR*)) + * coeffs_array = malloc(nvars * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * + * for i, (key, coeff) in enumerate(terms.items()): + */ + __pyx_v_coeffs_array = ((SCIP_Real *)malloc((__pyx_v_nvars * (sizeof(SCIP_Real))))); + + /* "src/pyscipopt/scip.pxi":2119 + * coeffs_array = malloc(nvars * sizeof(SCIP_Real)) + * + * for i, (key, coeff) in enumerate(terms.items()): # <<<<<<<<<<<<<< + * vars_array[i] = (key[0]).scip_var + * coeffs_array[i] = coeff + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_2 = __pyx_int_0; + __pyx_t_6 = 0; + if (unlikely(__pyx_v_terms == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 2119, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_dict_iterator(__pyx_v_terms, 0, __pyx_n_s_items, (&__pyx_t_7), (&__pyx_t_5)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + while (1) { + __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_7, &__pyx_t_6, &__pyx_t_4, &__pyx_t_8, NULL, __pyx_t_5); + if (unlikely(__pyx_t_9 == 0)) break; + if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 2119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_coeff, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_8; + __pyx_t_8 = 0; + + /* "src/pyscipopt/scip.pxi":2120 + * + * for i, (key, coeff) in enumerate(terms.items()): + * vars_array[i] = (key[0]).scip_var # <<<<<<<<<<<<<< + * coeffs_array[i] = coeff + * + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_key, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2120, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2120, __pyx_L1_error) + (__pyx_v_vars_array[__pyx_t_10]) = ((SCIP_VAR *)((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_8)->scip_var); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "src/pyscipopt/scip.pxi":2121 + * for i, (key, coeff) in enumerate(terms.items()): + * vars_array[i] = (key[0]).scip_var + * coeffs_array[i] = coeff # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPcreateConsLinear( + */ + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_v_coeff); if (unlikely((__pyx_t_11 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2121, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2121, __pyx_L1_error) + (__pyx_v_coeffs_array[__pyx_t_10]) = ((SCIP_Real)__pyx_t_11); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2123 + * coeffs_array[i] = coeff + * + * PY_SCIP_CALL(SCIPcreateConsLinear( # <<<<<<<<<<<<<< + * self._scip, &scip_cons, str_conversion(kwargs['name']), nvars, vars_array, coeffs_array, + * kwargs['lhs'], kwargs['rhs'], kwargs['initial'], + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "src/pyscipopt/scip.pxi":2124 + * + * PY_SCIP_CALL(SCIPcreateConsLinear( + * self._scip, &scip_cons, str_conversion(kwargs['name']), nvars, vars_array, coeffs_array, # <<<<<<<<<<<<<< + * kwargs['lhs'], kwargs['rhs'], kwargs['initial'], + * kwargs['separate'], kwargs['enforce'], kwargs['check'], + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_name); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_12}; + __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_14 = __Pyx_PyObject_AsWritableString(__pyx_t_8); if (unlikely((!__pyx_t_14) && PyErr_Occurred())) __PYX_ERR(0, 2124, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2125 + * PY_SCIP_CALL(SCIPcreateConsLinear( + * self._scip, &scip_cons, str_conversion(kwargs['name']), nvars, vars_array, coeffs_array, + * kwargs['lhs'], kwargs['rhs'], kwargs['initial'], # <<<<<<<<<<<<<< + * kwargs['separate'], kwargs['enforce'], kwargs['check'], + * kwargs['propagate'], kwargs['local'], kwargs['modifiable'], + */ + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_lhs); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_11 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_rhs); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_15 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_15 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_initial); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":2126 + * self._scip, &scip_cons, str_conversion(kwargs['name']), nvars, vars_array, coeffs_array, + * kwargs['lhs'], kwargs['rhs'], kwargs['initial'], + * kwargs['separate'], kwargs['enforce'], kwargs['check'], # <<<<<<<<<<<<<< + * kwargs['propagate'], kwargs['local'], kwargs['modifiable'], + * kwargs['dynamic'], kwargs['removable'], kwargs['stickingatnode'])) + */ + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_separate); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_17 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2126, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_enforce); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_18 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2126, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_check); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_19 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2126, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":2127 + * kwargs['lhs'], kwargs['rhs'], kwargs['initial'], + * kwargs['separate'], kwargs['enforce'], kwargs['check'], + * kwargs['propagate'], kwargs['local'], kwargs['modifiable'], # <<<<<<<<<<<<<< + * kwargs['dynamic'], kwargs['removable'], kwargs['stickingatnode'])) + * + */ + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_propagate); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_local); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_21 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_modifiable); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_22 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":2128 + * kwargs['separate'], kwargs['enforce'], kwargs['check'], + * kwargs['propagate'], kwargs['local'], kwargs['modifiable'], + * kwargs['dynamic'], kwargs['removable'], kwargs['stickingatnode'])) # <<<<<<<<<<<<<< + * + * PyCons = Constraint.create(scip_cons) + */ + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_dynamic); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_23 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_23 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_removable); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_24 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_stickingatnode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_25 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":2123 + * coeffs_array[i] = coeff + * + * PY_SCIP_CALL(SCIPcreateConsLinear( # <<<<<<<<<<<<<< + * self._scip, &scip_cons, str_conversion(kwargs['name']), nvars, vars_array, coeffs_array, + * kwargs['lhs'], kwargs['rhs'], kwargs['initial'], + */ + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsLinear(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_14, __pyx_v_nvars, __pyx_v_vars_array, __pyx_v_coeffs_array, __pyx_t_11, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_24, __pyx_t_25)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2130 + * kwargs['dynamic'], kwargs['removable'], kwargs['stickingatnode'])) + * + * PyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * + * free(vars_array) + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_PyCons = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2132 + * PyCons = Constraint.create(scip_cons) + * + * free(vars_array) # <<<<<<<<<<<<<< + * free(coeffs_array) + * return PyCons + */ + free(__pyx_v_vars_array); + + /* "src/pyscipopt/scip.pxi":2133 + * + * free(vars_array) + * free(coeffs_array) # <<<<<<<<<<<<<< + * return PyCons + * + */ + free(__pyx_v_coeffs_array); + + /* "src/pyscipopt/scip.pxi":2134 + * free(vars_array) + * free(coeffs_array) + * return PyCons # <<<<<<<<<<<<<< + * + * def _createConsQuadratic(self, ExprCons quadcons, **kwargs): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_PyCons); + __pyx_r = __pyx_v_PyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2106 + * return delayed, cutoff + * + * def _createConsLinear(self, ExprCons lincons, **kwargs): # <<<<<<<<<<<<<< + * assert isinstance(lincons, ExprCons), "given constraint is not ExprCons but %s" % lincons.__class__.__name__ + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("pyscipopt.scip.Model._createConsLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_terms); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_key); + __Pyx_XDECREF(__pyx_v_coeff); + __Pyx_XDECREF(__pyx_v_PyCons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2136 + * return PyCons + * + * def _createConsQuadratic(self, ExprCons quadcons, **kwargs): # <<<<<<<<<<<<<< + * terms = quadcons.expr.terms + * assert quadcons.expr.degree() <= 2, "given constraint is not quadratic, degree == %d" % quadcons.expr.degree() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_257_createConsQuadratic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_256_createConsQuadratic, "Model._createConsQuadratic(self, ExprCons quadcons, **kwargs)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_257_createConsQuadratic = {"_createConsQuadratic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_257_createConsQuadratic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_256_createConsQuadratic}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_257_createConsQuadratic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_quadcons = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_createConsQuadratic (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_quadcons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_quadcons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2136, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, kwd_pos_args, "_createConsQuadratic") < 0)) __PYX_ERR(0, 2136, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_quadcons = ((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_createConsQuadratic", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2136, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("pyscipopt.scip.Model._createConsQuadratic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_quadcons), __pyx_ptype_9pyscipopt_4scip_ExprCons, 1, "quadcons", 0))) __PYX_ERR(0, 2136, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_256_createConsQuadratic(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_quadcons, __pyx_v_kwargs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_DECREF(__pyx_v_kwargs); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_256_createConsQuadratic(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v_quadcons, PyObject *__pyx_v_kwargs) { + PyObject *__pyx_v_terms = NULL; + SCIP_CONS *__pyx_v_scip_cons; + SCIP_EXPR *__pyx_v_prodexpr; + PyObject *__pyx_v_v = NULL; + PyObject *__pyx_v_c = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + SCIP_EXPR **__pyx_v_varexprs; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var1 = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var2 = NULL; + PyObject *__pyx_v_PyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + char const *__pyx_t_9; + SCIP_Real __pyx_t_10; + SCIP_Real __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + SCIP_Bool __pyx_t_17; + SCIP_Bool __pyx_t_18; + SCIP_Bool __pyx_t_19; + SCIP_Bool __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + int __pyx_t_23; + Py_ssize_t __pyx_t_24; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_createConsQuadratic", 1); + + /* "src/pyscipopt/scip.pxi":2137 + * + * def _createConsQuadratic(self, ExprCons quadcons, **kwargs): + * terms = quadcons.expr.terms # <<<<<<<<<<<<<< + * assert quadcons.expr.degree() <= 2, "given constraint is not quadratic, degree == %d" % quadcons.expr.degree() + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_quadcons->expr, __pyx_n_s_terms); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_terms = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2138 + * def _createConsQuadratic(self, ExprCons quadcons, **kwargs): + * terms = quadcons.expr.terms + * assert quadcons.expr.degree() <= 2, "given constraint is not quadratic, degree == %d" % quadcons.expr.degree() # <<<<<<<<<<<<<< + * + * cdef SCIP_CONS* scip_cons + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_quadcons->expr, __pyx_n_s_degree); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_int_2, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 2138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_quadcons->expr, __pyx_n_s_degree); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_1 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_given_constraint_is_not_quadrati, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 2138, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2138, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2142 + * cdef SCIP_CONS* scip_cons + * cdef SCIP_EXPR* prodexpr + * PY_SCIP_CALL(SCIPcreateConsQuadraticNonlinear( # <<<<<<<<<<<<<< + * self._scip, &scip_cons, str_conversion(kwargs['name']), + * 0, NULL, NULL, # linear + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":2143 + * cdef SCIP_EXPR* prodexpr + * PY_SCIP_CALL(SCIPcreateConsQuadraticNonlinear( + * self._scip, &scip_cons, str_conversion(kwargs['name']), # <<<<<<<<<<<<<< + * 0, NULL, NULL, # linear + * 0, NULL, NULL, NULL, # quadratc + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_name); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_7}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_9 = __Pyx_PyObject_AsString(__pyx_t_3); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(0, 2143, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2146 + * 0, NULL, NULL, # linear + * 0, NULL, NULL, NULL, # quadratc + * kwargs['lhs'], kwargs['rhs'], # <<<<<<<<<<<<<< + * kwargs['initial'], kwargs['separate'], kwargs['enforce'], + * kwargs['check'], kwargs['propagate'], kwargs['local'], + */ + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_lhs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_10 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_rhs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_11 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2147 + * 0, NULL, NULL, NULL, # quadratc + * kwargs['lhs'], kwargs['rhs'], + * kwargs['initial'], kwargs['separate'], kwargs['enforce'], # <<<<<<<<<<<<<< + * kwargs['check'], kwargs['propagate'], kwargs['local'], + * kwargs['modifiable'], kwargs['dynamic'], kwargs['removable'])) + */ + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_initial); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2147, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_separate); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2147, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_enforce); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2147, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2147, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2148 + * kwargs['lhs'], kwargs['rhs'], + * kwargs['initial'], kwargs['separate'], kwargs['enforce'], + * kwargs['check'], kwargs['propagate'], kwargs['local'], # <<<<<<<<<<<<<< + * kwargs['modifiable'], kwargs['dynamic'], kwargs['removable'])) + * + */ + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_check); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_propagate); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_local); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_17 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2149 + * kwargs['initial'], kwargs['separate'], kwargs['enforce'], + * kwargs['check'], kwargs['propagate'], kwargs['local'], + * kwargs['modifiable'], kwargs['dynamic'], kwargs['removable'])) # <<<<<<<<<<<<<< + * + * for v, c in terms.items(): + */ + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_modifiable); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_18 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_dynamic); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_19 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_removable); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2142 + * cdef SCIP_CONS* scip_cons + * cdef SCIP_EXPR* prodexpr + * PY_SCIP_CALL(SCIPcreateConsQuadraticNonlinear( # <<<<<<<<<<<<<< + * self._scip, &scip_cons, str_conversion(kwargs['name']), + * 0, NULL, NULL, # linear + */ + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsQuadraticNonlinear(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_9, 0, NULL, NULL, 0, NULL, NULL, NULL, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2151 + * kwargs['modifiable'], kwargs['dynamic'], kwargs['removable'])) + * + * for v, c in terms.items(): # <<<<<<<<<<<<<< + * if len(v) == 1: # linear + * var = v[0] + */ + __pyx_t_21 = 0; + if (unlikely(__pyx_v_terms == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 2151, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_dict_iterator(__pyx_v_terms, 0, __pyx_n_s_items, (&__pyx_t_22), (&__pyx_t_4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_2; + __pyx_t_2 = 0; + while (1) { + __pyx_t_23 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_22, &__pyx_t_21, &__pyx_t_2, &__pyx_t_6, NULL, __pyx_t_4); + if (unlikely(__pyx_t_23 == 0)) break; + if (unlikely(__pyx_t_23 == -1)) __PYX_ERR(0, 2151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_c, __pyx_t_6); + __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2152 + * + * for v, c in terms.items(): + * if len(v) == 1: # linear # <<<<<<<<<<<<<< + * var = v[0] + * PY_SCIP_CALL(SCIPaddLinearVarNonlinear(self._scip, scip_cons, var.scip_var, c)) + */ + __pyx_t_24 = PyObject_Length(__pyx_v_v); if (unlikely(__pyx_t_24 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2152, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_24 == 1); + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":2153 + * for v, c in terms.items(): + * if len(v) == 1: # linear + * var = v[0] # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddLinearVarNonlinear(self._scip, scip_cons, var.scip_var, c)) + * else: # quadratic + */ + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2154 + * if len(v) == 1: # linear + * var = v[0] + * PY_SCIP_CALL(SCIPaddLinearVarNonlinear(self._scip, scip_cons, var.scip_var, c)) # <<<<<<<<<<<<<< + * else: # quadratic + * assert len(v) == 2, 'term length must be 1 or 2 but it is %s' % len(v) + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_v_c); if (unlikely((__pyx_t_11 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2154, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddLinearVarNonlinear(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_var->scip_var, __pyx_t_11)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2152 + * + * for v, c in terms.items(): + * if len(v) == 1: # linear # <<<<<<<<<<<<<< + * var = v[0] + * PY_SCIP_CALL(SCIPaddLinearVarNonlinear(self._scip, scip_cons, var.scip_var, c)) + */ + goto __pyx_L5; + } + + /* "src/pyscipopt/scip.pxi":2156 + * PY_SCIP_CALL(SCIPaddLinearVarNonlinear(self._scip, scip_cons, var.scip_var, c)) + * else: # quadratic + * assert len(v) == 2, 'term length must be 1 or 2 but it is %s' % len(v) # <<<<<<<<<<<<<< + * + * varexprs = malloc(2 * sizeof(SCIP_EXPR*)) + */ + /*else*/ { + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_24 = PyObject_Length(__pyx_v_v); if (unlikely(__pyx_t_24 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2156, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_24 == 2); + if (unlikely(!__pyx_t_5)) { + __pyx_t_24 = PyObject_Length(__pyx_v_v); if (unlikely(__pyx_t_24 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2156, __pyx_L1_error) + __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_24); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_term_length_must_be_1_or_2_but_i, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_6, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 2156, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2156, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2158 + * assert len(v) == 2, 'term length must be 1 or 2 but it is %s' % len(v) + * + * varexprs = malloc(2 * sizeof(SCIP_EXPR*)) # <<<<<<<<<<<<<< + * var1, var2 = v[0], v[1] + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[0], var1.scip_var, NULL, NULL) ) + */ + __pyx_v_varexprs = ((SCIP_EXPR **)malloc((2 * (sizeof(SCIP_EXPR *))))); + + /* "src/pyscipopt/scip.pxi":2159 + * + * varexprs = malloc(2 * sizeof(SCIP_EXPR*)) + * var1, var2 = v[0], v[1] # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[0], var1.scip_var, NULL, NULL) ) + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[1], var2.scip_var, NULL, NULL) ) + */ + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF_SET(__pyx_v_var1, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2)); + __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_var2, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2160 + * varexprs = malloc(2 * sizeof(SCIP_EXPR*)) + * var1, var2 = v[0], v[1] + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[0], var1.scip_var, NULL, NULL) ) # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[1], var2.scip_var, NULL, NULL) ) + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &prodexpr, 2, varexprs, 1.0, NULL, NULL) ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprVar(__pyx_v_self->_scip, (&(__pyx_v_varexprs[0])), __pyx_v_var1->scip_var, NULL, NULL)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2161 + * var1, var2 = v[0], v[1] + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[0], var1.scip_var, NULL, NULL) ) + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[1], var2.scip_var, NULL, NULL) ) # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &prodexpr, 2, varexprs, 1.0, NULL, NULL) ) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprVar(__pyx_v_self->_scip, (&(__pyx_v_varexprs[1])), __pyx_v_var2->scip_var, NULL, NULL)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2162 + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[0], var1.scip_var, NULL, NULL) ) + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[1], var2.scip_var, NULL, NULL) ) + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &prodexpr, 2, varexprs, 1.0, NULL, NULL) ) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL( SCIPaddExprNonlinear(self._scip, scip_cons, prodexpr, c) ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprProduct(__pyx_v_self->_scip, (&__pyx_v_prodexpr), 2, __pyx_v_varexprs, 1.0, NULL, NULL)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2164 + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &prodexpr, 2, varexprs, 1.0, NULL, NULL) ) + * + * PY_SCIP_CALL( SCIPaddExprNonlinear(self._scip, scip_cons, prodexpr, c) ) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &prodexpr) ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_v_c); if (unlikely((__pyx_t_11 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2164, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddExprNonlinear(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_prodexpr, __pyx_t_11)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2166 + * PY_SCIP_CALL( SCIPaddExprNonlinear(self._scip, scip_cons, prodexpr, c) ) + * + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &prodexpr) ) # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[1]) ) + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[0]) ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseExpr(__pyx_v_self->_scip, (&__pyx_v_prodexpr))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2167 + * + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &prodexpr) ) + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[1]) ) # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[0]) ) + * free(varexprs) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseExpr(__pyx_v_self->_scip, (&(__pyx_v_varexprs[1])))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2168 + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &prodexpr) ) + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[1]) ) + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[0]) ) # <<<<<<<<<<<<<< + * free(varexprs) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseExpr(__pyx_v_self->_scip, (&(__pyx_v_varexprs[0])))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2168, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2169 + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[1]) ) + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[0]) ) + * free(varexprs) # <<<<<<<<<<<<<< + * + * PyCons = Constraint.create(scip_cons) + */ + free(__pyx_v_varexprs); + } + __pyx_L5:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2171 + * free(varexprs) + * + * PyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * + * return PyCons + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2173 + * PyCons = Constraint.create(scip_cons) + * + * return PyCons # <<<<<<<<<<<<<< + * + * def _createConsNonlinear(self, cons, **kwargs): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_PyCons); + __pyx_r = __pyx_v_PyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2136 + * return PyCons + * + * def _createConsQuadratic(self, ExprCons quadcons, **kwargs): # <<<<<<<<<<<<<< + * terms = quadcons.expr.terms + * assert quadcons.expr.degree() <= 2, "given constraint is not quadratic, degree == %d" % quadcons.expr.degree() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model._createConsQuadratic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_terms); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XDECREF(__pyx_v_c); + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XDECREF((PyObject *)__pyx_v_var1); + __Pyx_XDECREF((PyObject *)__pyx_v_var2); + __Pyx_XDECREF(__pyx_v_PyCons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2175 + * return PyCons + * + * def _createConsNonlinear(self, cons, **kwargs): # <<<<<<<<<<<<<< + * cdef SCIP_EXPR* expr + * cdef SCIP_EXPR** varexprs + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_259_createConsNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_258_createConsNonlinear, "Model._createConsNonlinear(self, cons, **kwargs)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_259_createConsNonlinear = {"_createConsNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_259_createConsNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_258_createConsNonlinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_259_createConsNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_cons = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_createConsNonlinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2175, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, kwd_pos_args, "_createConsNonlinear") < 0)) __PYX_ERR(0, 2175, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_createConsNonlinear", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2175, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("pyscipopt.scip.Model._createConsNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_258_createConsNonlinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_kwargs); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_kwargs); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_258_createConsNonlinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_kwargs) { + SCIP_EXPR *__pyx_v_expr; + SCIP_EXPR **__pyx_v_monomials; + SCIP_CONS *__pyx_v_scip_cons; + PyObject *__pyx_v_terms = NULL; + PyObject *__pyx_v_variables = NULL; + CYTHON_UNUSED PyObject *__pyx_v_varindex = NULL; + SCIP_Real *__pyx_v_termcoefs; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_term = NULL; + PyObject *__pyx_v_coef = NULL; + SCIP_VAR **__pyx_v_termvars; + PyObject *__pyx_v_j = NULL; + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_v_PyCons = NULL; + PyObject *__pyx_9genexpr35__pyx_v_term = NULL; + PyObject *__pyx_9genexpr35__pyx_v_var = NULL; + PyObject *__pyx_9genexpr36__pyx_v_idx = NULL; + PyObject *__pyx_9genexpr36__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_t_12; + Py_ssize_t __pyx_t_13; + SCIP_VAR *__pyx_t_14; + Py_ssize_t __pyx_t_15; + SCIP_Real __pyx_t_16; + char const *__pyx_t_17; + SCIP_Real __pyx_t_18; + SCIP_Bool __pyx_t_19; + SCIP_Bool __pyx_t_20; + SCIP_Bool __pyx_t_21; + SCIP_Bool __pyx_t_22; + SCIP_Bool __pyx_t_23; + SCIP_Bool __pyx_t_24; + SCIP_Bool __pyx_t_25; + SCIP_Bool __pyx_t_26; + SCIP_Bool __pyx_t_27; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_createConsNonlinear", 1); + + /* "src/pyscipopt/scip.pxi":2182 + * cdef SCIP_CONS* scip_cons + * + * terms = cons.expr.terms # <<<<<<<<<<<<<< + * + * # collect variables + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_expr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_terms); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2182, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_terms = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2185 + * + * # collect variables + * variables = {var.ptr():var for term in terms for var in term} # <<<<<<<<<<<<<< + * variables = list(variables.values()) + * varindex = {var.ptr():idx for (idx,var) in enumerate(variables)} + */ + { /* enter inner scope */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_v_terms)) || PyTuple_CheckExact(__pyx_v_terms)) { + __pyx_t_1 = __pyx_v_terms; __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_terms); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2185, __pyx_L5_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2185, __pyx_L5_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 2185, __pyx_L5_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2185, __pyx_L5_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 2185, __pyx_L5_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_1); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2185, __pyx_L5_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_9genexpr35__pyx_v_term, __pyx_t_5); + __pyx_t_5 = 0; + if (likely(PyList_CheckExact(__pyx_9genexpr35__pyx_v_term)) || PyTuple_CheckExact(__pyx_9genexpr35__pyx_v_term)) { + __pyx_t_5 = __pyx_9genexpr35__pyx_v_term; __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_9genexpr35__pyx_v_term); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2185, __pyx_L5_error) + } + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_5))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2185, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 2185, __pyx_L5_error) + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2185, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_8); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 2185, __pyx_L5_error) + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_7(__pyx_t_5); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2185, __pyx_L5_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_9genexpr35__pyx_v_var, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr35__pyx_v_var, __pyx_n_s_ptr); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL}; + __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_11, 0+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + if (unlikely(PyDict_SetItem(__pyx_t_2, (PyObject*)__pyx_t_8, (PyObject*)__pyx_9genexpr35__pyx_v_var))) __PYX_ERR(0, 2185, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_9genexpr35__pyx_v_term); __pyx_9genexpr35__pyx_v_term = 0; + __Pyx_XDECREF(__pyx_9genexpr35__pyx_v_var); __pyx_9genexpr35__pyx_v_var = 0; + goto __pyx_L12_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_9genexpr35__pyx_v_term); __pyx_9genexpr35__pyx_v_term = 0; + __Pyx_XDECREF(__pyx_9genexpr35__pyx_v_var); __pyx_9genexpr35__pyx_v_var = 0; + goto __pyx_L1_error; + __pyx_L12_exit_scope:; + } /* exit inner scope */ + __pyx_v_variables = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2186 + * # collect variables + * variables = {var.ptr():var for term in terms for var in term} + * variables = list(variables.values()) # <<<<<<<<<<<<<< + * varindex = {var.ptr():idx for (idx,var) in enumerate(variables)} + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_variables, __pyx_n_s_values); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_11, 0+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_1 = __Pyx_PySequence_ListKeepNew(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_variables, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2187 + * variables = {var.ptr():var for term in terms for var in term} + * variables = list(variables.values()) + * varindex = {var.ptr():idx for (idx,var) in enumerate(variables)} # <<<<<<<<<<<<<< + * + * # create monomials for terms + */ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2187, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_int_0); + __pyx_t_2 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_variables)) || PyTuple_CheckExact(__pyx_v_variables)) { + __pyx_t_5 = __pyx_v_variables; __Pyx_INCREF(__pyx_t_5); + __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_v_variables); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2187, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2187, __pyx_L15_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_5))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2187, __pyx_L15_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_8); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 2187, __pyx_L15_error) + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2187, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2187, __pyx_L15_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_8); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 2187, __pyx_L15_error) + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2187, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + } + } else { + __pyx_t_8 = __pyx_t_4(__pyx_t_5); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2187, __pyx_L15_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_XDECREF_SET(__pyx_9genexpr36__pyx_v_var, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_9genexpr36__pyx_v_idx, __pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2187, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_8; + __pyx_t_8 = 0; + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr36__pyx_v_var, __pyx_n_s_ptr); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2187, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, NULL}; + __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_11, 0+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2187, __pyx_L15_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_t_8, (PyObject*)__pyx_9genexpr36__pyx_v_idx))) __PYX_ERR(0, 2187, __pyx_L15_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_idx); __pyx_9genexpr36__pyx_v_idx = 0; + __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_var); __pyx_9genexpr36__pyx_v_var = 0; + goto __pyx_L19_exit_scope; + __pyx_L15_error:; + __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_idx); __pyx_9genexpr36__pyx_v_idx = 0; + __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_var); __pyx_9genexpr36__pyx_v_var = 0; + goto __pyx_L1_error; + __pyx_L19_exit_scope:; + } /* exit inner scope */ + __pyx_v_varindex = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2190 + * + * # create monomials for terms + * monomials = malloc(len(terms) * sizeof(SCIP_EXPR*)) # <<<<<<<<<<<<<< + * termcoefs = malloc(len(terms) * sizeof(SCIP_Real)) + * for i, (term, coef) in enumerate(terms.items()): + */ + __pyx_t_3 = PyObject_Length(__pyx_v_terms); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2190, __pyx_L1_error) + __pyx_v_monomials = ((SCIP_EXPR **)malloc((__pyx_t_3 * (sizeof(SCIP_EXPR *))))); + + /* "src/pyscipopt/scip.pxi":2191 + * # create monomials for terms + * monomials = malloc(len(terms) * sizeof(SCIP_EXPR*)) + * termcoefs = malloc(len(terms) * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * for i, (term, coef) in enumerate(terms.items()): + * termvars = malloc(len(term) * sizeof(SCIP_VAR*)) + */ + __pyx_t_3 = PyObject_Length(__pyx_v_terms); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2191, __pyx_L1_error) + __pyx_v_termcoefs = ((SCIP_Real *)malloc((__pyx_t_3 * (sizeof(SCIP_Real))))); + + /* "src/pyscipopt/scip.pxi":2192 + * monomials = malloc(len(terms) * sizeof(SCIP_EXPR*)) + * termcoefs = malloc(len(terms) * sizeof(SCIP_Real)) + * for i, (term, coef) in enumerate(terms.items()): # <<<<<<<<<<<<<< + * termvars = malloc(len(term) * sizeof(SCIP_VAR*)) + * for j, var in enumerate(term): + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_1 = __pyx_int_0; + __pyx_t_3 = 0; + if (unlikely(__pyx_v_terms == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 2192, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_terms, 0, __pyx_n_s_items, (&__pyx_t_6), (&__pyx_t_11)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_12 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_6, &__pyx_t_3, &__pyx_t_5, &__pyx_t_8, NULL, __pyx_t_11); + if (unlikely(__pyx_t_12 == 0)) break; + if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 2192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_term, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_coef, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_8; + __pyx_t_8 = 0; + + /* "src/pyscipopt/scip.pxi":2193 + * termcoefs = malloc(len(terms) * sizeof(SCIP_Real)) + * for i, (term, coef) in enumerate(terms.items()): + * termvars = malloc(len(term) * sizeof(SCIP_VAR*)) # <<<<<<<<<<<<<< + * for j, var in enumerate(term): + * termvars[j] = (var).scip_var + */ + __pyx_t_13 = PyObject_Length(__pyx_v_term); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2193, __pyx_L1_error) + __pyx_v_termvars = ((SCIP_VAR **)malloc((__pyx_t_13 * (sizeof(SCIP_VAR *))))); + + /* "src/pyscipopt/scip.pxi":2194 + * for i, (term, coef) in enumerate(terms.items()): + * termvars = malloc(len(term) * sizeof(SCIP_VAR*)) + * for j, var in enumerate(term): # <<<<<<<<<<<<<< + * termvars[j] = (var).scip_var + * PY_SCIP_CALL( SCIPcreateExprMonomial(self._scip, &monomials[i], len(term), termvars, NULL, NULL, NULL) ) + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_8 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_term)) || PyTuple_CheckExact(__pyx_v_term)) { + __pyx_t_5 = __pyx_v_term; __Pyx_INCREF(__pyx_t_5); + __pyx_t_13 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_13 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_v_term); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2194, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_5))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2194, __pyx_L1_error) + #endif + if (__pyx_t_13 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_13); __Pyx_INCREF(__pyx_t_9); __pyx_t_13++; if (unlikely((0 < 0))) __PYX_ERR(0, 2194, __pyx_L1_error) + #else + __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2194, __pyx_L1_error) + #endif + if (__pyx_t_13 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_13); __Pyx_INCREF(__pyx_t_9); __pyx_t_13++; if (unlikely((0 < 0))) __PYX_ERR(0, 2194, __pyx_L1_error) + #else + __pyx_t_9 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_4(__pyx_t_5); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2194, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_9); + __pyx_t_9 = 0; + __Pyx_INCREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_j, __pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_AddObjC(__pyx_t_8, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_8); + __pyx_t_8 = __pyx_t_9; + __pyx_t_9 = 0; + + /* "src/pyscipopt/scip.pxi":2195 + * termvars = malloc(len(term) * sizeof(SCIP_VAR*)) + * for j, var in enumerate(term): + * termvars[j] = (var).scip_var # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprMonomial(self._scip, &monomials[i], len(term), termvars, NULL, NULL, NULL) ) + * termcoefs[i] = coef + */ + __pyx_t_14 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_var)->scip_var; + __pyx_t_15 = __Pyx_PyIndex_AsSsize_t(__pyx_v_j); if (unlikely((__pyx_t_15 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2195, __pyx_L1_error) + (__pyx_v_termvars[__pyx_t_15]) = __pyx_t_14; + + /* "src/pyscipopt/scip.pxi":2194 + * for i, (term, coef) in enumerate(terms.items()): + * termvars = malloc(len(term) * sizeof(SCIP_VAR*)) + * for j, var in enumerate(term): # <<<<<<<<<<<<<< + * termvars[j] = (var).scip_var + * PY_SCIP_CALL( SCIPcreateExprMonomial(self._scip, &monomials[i], len(term), termvars, NULL, NULL, NULL) ) + */ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "src/pyscipopt/scip.pxi":2196 + * for j, var in enumerate(term): + * termvars[j] = (var).scip_var + * PY_SCIP_CALL( SCIPcreateExprMonomial(self._scip, &monomials[i], len(term), termvars, NULL, NULL, NULL) ) # <<<<<<<<<<<<<< + * termcoefs[i] = coef + * free(termvars) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_13 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_13 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2196, __pyx_L1_error) + __pyx_t_15 = PyObject_Length(__pyx_v_term); if (unlikely(__pyx_t_15 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2196, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprMonomial(__pyx_v_self->_scip, (&(__pyx_v_monomials[__pyx_t_13])), ((int)__pyx_t_15), __pyx_v_termvars, NULL, NULL, NULL)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_12 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_12 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_12, 1+__pyx_t_12); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "src/pyscipopt/scip.pxi":2197 + * termvars[j] = (var).scip_var + * PY_SCIP_CALL( SCIPcreateExprMonomial(self._scip, &monomials[i], len(term), termvars, NULL, NULL, NULL) ) + * termcoefs[i] = coef # <<<<<<<<<<<<<< + * free(termvars) + * + */ + __pyx_t_16 = __pyx_PyFloat_AsDouble(__pyx_v_coef); if (unlikely((__pyx_t_16 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2197, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_15 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2197, __pyx_L1_error) + (__pyx_v_termcoefs[__pyx_t_15]) = ((SCIP_Real)__pyx_t_16); + + /* "src/pyscipopt/scip.pxi":2198 + * PY_SCIP_CALL( SCIPcreateExprMonomial(self._scip, &monomials[i], len(term), termvars, NULL, NULL, NULL) ) + * termcoefs[i] = coef + * free(termvars) # <<<<<<<<<<<<<< + * + * # create polynomial from monomials + */ + free(__pyx_v_termvars); + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2201 + * + * # create polynomial from monomials + * PY_SCIP_CALL( SCIPcreateExprSum(self._scip, &expr, len(terms), monomials, termcoefs, 0.0, NULL, NULL)) # <<<<<<<<<<<<<< + * + * # create nonlinear constraint for expr + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = PyObject_Length(__pyx_v_terms); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2201, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprSum(__pyx_v_self->_scip, (&__pyx_v_expr), ((int)__pyx_t_6), __pyx_v_monomials, __pyx_v_termcoefs, 0.0, NULL, NULL)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2204 + * + * # create nonlinear constraint for expr + * PY_SCIP_CALL( SCIPcreateConsNonlinear( # <<<<<<<<<<<<<< + * self._scip, + * &scip_cons, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":2207 + * self._scip, + * &scip_cons, + * str_conversion(kwargs['name']), # <<<<<<<<<<<<<< + * expr, + * kwargs['lhs'], + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_name); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_8 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_17 = __Pyx_PyObject_AsString(__pyx_t_8); if (unlikely((!__pyx_t_17) && PyErr_Occurred())) __PYX_ERR(0, 2207, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2209 + * str_conversion(kwargs['name']), + * expr, + * kwargs['lhs'], # <<<<<<<<<<<<<< + * kwargs['rhs'], + * kwargs['initial'], + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_lhs); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_16 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_16 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2210 + * expr, + * kwargs['lhs'], + * kwargs['rhs'], # <<<<<<<<<<<<<< + * kwargs['initial'], + * kwargs['separate'], + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_rhs); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_18 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_18 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2211 + * kwargs['lhs'], + * kwargs['rhs'], + * kwargs['initial'], # <<<<<<<<<<<<<< + * kwargs['separate'], + * kwargs['enforce'], + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_initial); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_19 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2211, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2212 + * kwargs['rhs'], + * kwargs['initial'], + * kwargs['separate'], # <<<<<<<<<<<<<< + * kwargs['enforce'], + * kwargs['check'], + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_separate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2212, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2213 + * kwargs['initial'], + * kwargs['separate'], + * kwargs['enforce'], # <<<<<<<<<<<<<< + * kwargs['check'], + * kwargs['propagate'], + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_enforce); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_21 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2213, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2214 + * kwargs['separate'], + * kwargs['enforce'], + * kwargs['check'], # <<<<<<<<<<<<<< + * kwargs['propagate'], + * kwargs['local'], + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_check); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_22 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2214, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2215 + * kwargs['enforce'], + * kwargs['check'], + * kwargs['propagate'], # <<<<<<<<<<<<<< + * kwargs['local'], + * kwargs['modifiable'], + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_propagate); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2215, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_23 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_23 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2215, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2216 + * kwargs['check'], + * kwargs['propagate'], + * kwargs['local'], # <<<<<<<<<<<<<< + * kwargs['modifiable'], + * kwargs['dynamic'], + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_local); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_24 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2217 + * kwargs['propagate'], + * kwargs['local'], + * kwargs['modifiable'], # <<<<<<<<<<<<<< + * kwargs['dynamic'], + * kwargs['removable']) ) + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_modifiable); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_25 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2217, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2218 + * kwargs['local'], + * kwargs['modifiable'], + * kwargs['dynamic'], # <<<<<<<<<<<<<< + * kwargs['removable']) ) + * + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_dynamic); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_26 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2219 + * kwargs['modifiable'], + * kwargs['dynamic'], + * kwargs['removable']) ) # <<<<<<<<<<<<<< + * + * PyCons = Constraint.create(scip_cons) + */ + __pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_removable); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_27 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2219, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2204 + * + * # create nonlinear constraint for expr + * PY_SCIP_CALL( SCIPcreateConsNonlinear( # <<<<<<<<<<<<<< + * self._scip, + * &scip_cons, + */ + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsNonlinear(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_17, __pyx_v_expr, __pyx_t_16, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_t_27)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2221 + * kwargs['removable']) ) + * + * PyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &expr) ) + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2223 + * PyCons = Constraint.create(scip_cons) + * + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &expr) ) # <<<<<<<<<<<<<< + * for i in range(len(terms)): + * PY_SCIP_CALL(SCIPreleaseExpr(self._scip, &monomials[i])) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseExpr(__pyx_v_self->_scip, (&__pyx_v_expr))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2224 + * + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &expr) ) + * for i in range(len(terms)): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseExpr(self._scip, &monomials[i])) + * free(monomials) + */ + __pyx_t_6 = PyObject_Length(__pyx_v_terms); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2224, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyInt_From_int(((int)__pyx_t_6)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); + __pyx_t_6 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2224, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2224, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 2224, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2224, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 2224, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_4(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2224, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2225 + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &expr) ) + * for i in range(len(terms)): + * PY_SCIP_CALL(SCIPreleaseExpr(self._scip, &monomials[i])) # <<<<<<<<<<<<<< + * free(monomials) + * free(termcoefs) + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2225, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseExpr(__pyx_v_self->_scip, (&(__pyx_v_monomials[__pyx_t_3])))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2224 + * + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &expr) ) + * for i in range(len(terms)): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseExpr(self._scip, &monomials[i])) + * free(monomials) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2226 + * for i in range(len(terms)): + * PY_SCIP_CALL(SCIPreleaseExpr(self._scip, &monomials[i])) + * free(monomials) # <<<<<<<<<<<<<< + * free(termcoefs) + * return PyCons + */ + free(__pyx_v_monomials); + + /* "src/pyscipopt/scip.pxi":2227 + * PY_SCIP_CALL(SCIPreleaseExpr(self._scip, &monomials[i])) + * free(monomials) + * free(termcoefs) # <<<<<<<<<<<<<< + * return PyCons + * + */ + free(__pyx_v_termcoefs); + + /* "src/pyscipopt/scip.pxi":2228 + * free(monomials) + * free(termcoefs) + * return PyCons # <<<<<<<<<<<<<< + * + * def _createConsGenNonlinear(self, cons, **kwargs): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_PyCons); + __pyx_r = __pyx_v_PyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2175 + * return PyCons + * + * def _createConsNonlinear(self, cons, **kwargs): # <<<<<<<<<<<<<< + * cdef SCIP_EXPR* expr + * cdef SCIP_EXPR** varexprs + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pyscipopt.scip.Model._createConsNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_terms); + __Pyx_XDECREF(__pyx_v_variables); + __Pyx_XDECREF(__pyx_v_varindex); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_term); + __Pyx_XDECREF(__pyx_v_coef); + __Pyx_XDECREF(__pyx_v_j); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XDECREF(__pyx_v_PyCons); + __Pyx_XDECREF(__pyx_9genexpr35__pyx_v_term); + __Pyx_XDECREF(__pyx_9genexpr35__pyx_v_var); + __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_idx); + __Pyx_XDECREF(__pyx_9genexpr36__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2230 + * return PyCons + * + * def _createConsGenNonlinear(self, cons, **kwargs): # <<<<<<<<<<<<<< + * cdef SCIP_EXPR** childrenexpr + * cdef SCIP_EXPR** scipexprs + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_261_createConsGenNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_260_createConsGenNonlinear, "Model._createConsGenNonlinear(self, cons, **kwargs)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_261_createConsGenNonlinear = {"_createConsGenNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_261_createConsGenNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_260_createConsGenNonlinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_261_createConsGenNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_cons = 0; + PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_createConsGenNonlinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + __pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2230, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values + 0, kwd_pos_args, "_createConsGenNonlinear") < 0)) __PYX_ERR(0, 2230, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("_createConsGenNonlinear", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2230, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("pyscipopt.scip.Model._createConsGenNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_260_createConsGenNonlinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_kwargs); + + /* function exit code */ + __Pyx_DECREF(__pyx_v_kwargs); + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_260_createConsGenNonlinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_kwargs) { + SCIP_EXPR **__pyx_v_childrenexpr; + SCIP_EXPR **__pyx_v_scipexprs; + SCIP_CONS *__pyx_v_scip_cons; + int __pyx_v_nchildren; + PyObject *__pyx_v_expr = NULL; + PyObject *__pyx_v_nodes = NULL; + PyObject *__pyx_v_nvars = NULL; + PyObject *__pyx_v_node = NULL; + SCIP_VAR **__pyx_v_vars; + PyObject *__pyx_v_varpos = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_opidx = NULL; + PyObject *__pyx_v_pyvar = NULL; + PyObject *__pyx_v_value = NULL; + SCIP_Real *__pyx_v_coefs; + PyObject *__pyx_v_c = NULL; + PyObject *__pyx_v_pos = NULL; + PyObject *__pyx_v_valuenode = NULL; + PyObject *__pyx_v_exponent = NULL; + PyObject *__pyx_v_PyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + size_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + SCIP_VAR *__pyx_t_13; + SCIP_Real __pyx_t_14; + PyObject *(*__pyx_t_15)(PyObject *); + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + char const *__pyx_t_18; + SCIP_Real __pyx_t_19; + SCIP_Bool __pyx_t_20; + SCIP_Bool __pyx_t_21; + SCIP_Bool __pyx_t_22; + SCIP_Bool __pyx_t_23; + SCIP_Bool __pyx_t_24; + SCIP_Bool __pyx_t_25; + SCIP_Bool __pyx_t_26; + SCIP_Bool __pyx_t_27; + SCIP_Bool __pyx_t_28; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_createConsGenNonlinear", 1); + + /* "src/pyscipopt/scip.pxi":2237 + * + * # get arrays from python's expression tree + * expr = cons.expr # <<<<<<<<<<<<<< + * nodes = expr_to_nodes(expr) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_expr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_expr = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2238 + * # get arrays from python's expression tree + * expr = cons.expr + * nodes = expr_to_nodes(expr) # <<<<<<<<<<<<<< + * + * # in nodes we have a list of tuples: each tuple is of the form + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_expr_to_nodes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_expr}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_nodes = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2248 + * # Note2: we need to compute the number of variable operators to find out + * # how many variables are there. + * nvars = 0 # <<<<<<<<<<<<<< + * for node in nodes: + * if node[0] == Operator.varidx: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_nvars = __pyx_int_0; + + /* "src/pyscipopt/scip.pxi":2249 + * # how many variables are there. + * nvars = 0 + * for node in nodes: # <<<<<<<<<<<<<< + * if node[0] == Operator.varidx: + * nvars += 1 + */ + if (likely(PyList_CheckExact(__pyx_v_nodes)) || PyTuple_CheckExact(__pyx_v_nodes)) { + __pyx_t_1 = __pyx_v_nodes; __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_nodes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2249, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2249, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 2249, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2249, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 2249, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_6(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2249, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_node, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2250 + * nvars = 0 + * for node in nodes: + * if node[0] == Operator.varidx: # <<<<<<<<<<<<<< + * nvars += 1 + * vars = malloc(nvars * sizeof(SCIP_VAR*)) + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_node, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Operator); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_varidx); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2250, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2250, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2251 + * for node in nodes: + * if node[0] == Operator.varidx: + * nvars += 1 # <<<<<<<<<<<<<< + * vars = malloc(nvars * sizeof(SCIP_VAR*)) + * + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_nvars, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_nvars, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2250 + * nvars = 0 + * for node in nodes: + * if node[0] == Operator.varidx: # <<<<<<<<<<<<<< + * nvars += 1 + * vars = malloc(nvars * sizeof(SCIP_VAR*)) + */ + } + + /* "src/pyscipopt/scip.pxi":2249 + * # how many variables are there. + * nvars = 0 + * for node in nodes: # <<<<<<<<<<<<<< + * if node[0] == Operator.varidx: + * nvars += 1 + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2252 + * if node[0] == Operator.varidx: + * nvars += 1 + * vars = malloc(nvars * sizeof(SCIP_VAR*)) # <<<<<<<<<<<<<< + * + * varpos = 0 + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(SCIP_VAR *))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyNumber_Multiply(__pyx_v_nvars, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2252, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_vars = ((SCIP_VAR **)malloc(__pyx_t_9)); + + /* "src/pyscipopt/scip.pxi":2254 + * vars = malloc(nvars * sizeof(SCIP_VAR*)) + * + * varpos = 0 # <<<<<<<<<<<<<< + * scipexprs = malloc(len(nodes) * sizeof(SCIP_EXPR*)) + * for i,node in enumerate(nodes): + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_v_varpos = __pyx_int_0; + + /* "src/pyscipopt/scip.pxi":2255 + * + * varpos = 0 + * scipexprs = malloc(len(nodes) * sizeof(SCIP_EXPR*)) # <<<<<<<<<<<<<< + * for i,node in enumerate(nodes): + * opidx = node[0] + */ + __pyx_t_5 = PyObject_Length(__pyx_v_nodes); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2255, __pyx_L1_error) + __pyx_v_scipexprs = ((SCIP_EXPR **)malloc((__pyx_t_5 * (sizeof(SCIP_EXPR *))))); + + /* "src/pyscipopt/scip.pxi":2256 + * varpos = 0 + * scipexprs = malloc(len(nodes) * sizeof(SCIP_EXPR*)) + * for i,node in enumerate(nodes): # <<<<<<<<<<<<<< + * opidx = node[0] + * if opidx == Operator.varidx: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_nodes)) || PyTuple_CheckExact(__pyx_v_nodes)) { + __pyx_t_1 = __pyx_v_nodes; __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_nodes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2256, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2256, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 2256, __pyx_L1_error) + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2256, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 2256, __pyx_L1_error) + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_1); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2256, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_node, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2257 + * scipexprs = malloc(len(nodes) * sizeof(SCIP_EXPR*)) + * for i,node in enumerate(nodes): + * opidx = node[0] # <<<<<<<<<<<<<< + * if opidx == Operator.varidx: + * assert len(node[1]) == 1 + */ + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_opidx, __pyx_t_7); + __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2258 + * for i,node in enumerate(nodes): + * opidx = node[0] + * if opidx == Operator.varidx: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * pyvar = node[1][0] # for vars we store the actual var! + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_Operator); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_varidx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2258, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2258, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2259 + * opidx = node[0] + * if opidx == Operator.varidx: + * assert len(node[1]) == 1 # <<<<<<<<<<<<<< + * pyvar = node[1][0] # for vars we store the actual var! + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &scipexprs[i], (pyvar).scip_var, NULL, NULL) ) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = PyObject_Length(__pyx_t_7); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2259, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = (__pyx_t_10 == 1); + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2259, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2259, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2260 + * if opidx == Operator.varidx: + * assert len(node[1]) == 1 + * pyvar = node[1][0] # for vars we store the actual var! # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &scipexprs[i], (pyvar).scip_var, NULL, NULL) ) + * vars[varpos] = (pyvar).scip_var + */ + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_v_pyvar, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2261 + * assert len(node[1]) == 1 + * pyvar = node[1][0] # for vars we store the actual var! + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &scipexprs[i], (pyvar).scip_var, NULL, NULL) ) # <<<<<<<<<<<<<< + * vars[varpos] = (pyvar).scip_var + * varpos += 1 + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2261, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprVar(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_10])), ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_pyvar)->scip_var, NULL, NULL)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_11}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2262 + * pyvar = node[1][0] # for vars we store the actual var! + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &scipexprs[i], (pyvar).scip_var, NULL, NULL) ) + * vars[varpos] = (pyvar).scip_var # <<<<<<<<<<<<<< + * varpos += 1 + * continue + */ + __pyx_t_13 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_pyvar)->scip_var; + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_varpos); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2262, __pyx_L1_error) + (__pyx_v_vars[__pyx_t_10]) = __pyx_t_13; + + /* "src/pyscipopt/scip.pxi":2263 + * PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &scipexprs[i], (pyvar).scip_var, NULL, NULL) ) + * vars[varpos] = (pyvar).scip_var + * varpos += 1 # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.const: + */ + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_v_varpos, __pyx_int_1, 1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_varpos, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2264 + * vars[varpos] = (pyvar).scip_var + * varpos += 1 + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.const: + * assert len(node[1]) == 1 + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2258 + * for i,node in enumerate(nodes): + * opidx = node[0] + * if opidx == Operator.varidx: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * pyvar = node[1][0] # for vars we store the actual var! + */ + } + + /* "src/pyscipopt/scip.pxi":2265 + * varpos += 1 + * continue + * if opidx == Operator.const: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * value = node[1][0] + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_const); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2265, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2265, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2266 + * continue + * if opidx == Operator.const: + * assert len(node[1]) == 1 # <<<<<<<<<<<<<< + * value = node[1][0] + * PY_SCIP_CALL( SCIPcreateExprValue(self._scip, &scipexprs[i], value, NULL, NULL) ) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2266, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = (__pyx_t_10 == 1); + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2266, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2266, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2267 + * if opidx == Operator.const: + * assert len(node[1]) == 1 + * value = node[1][0] # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprValue(self._scip, &scipexprs[i], value, NULL, NULL) ) + * continue + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_7); + __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2268 + * assert len(node[1]) == 1 + * value = node[1][0] + * PY_SCIP_CALL( SCIPcreateExprValue(self._scip, &scipexprs[i], value, NULL, NULL) ) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.add: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2268, __pyx_L1_error) + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_14 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2268, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprValue(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_10])), ((SCIP_Real)__pyx_t_14), NULL, NULL)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_11}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2269 + * value = node[1][0] + * PY_SCIP_CALL( SCIPcreateExprValue(self._scip, &scipexprs[i], value, NULL, NULL) ) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.add: + * nchildren = len(node[1]) + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2265 + * varpos += 1 + * continue + * if opidx == Operator.const: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * value = node[1][0] + */ + } + + /* "src/pyscipopt/scip.pxi":2270 + * PY_SCIP_CALL( SCIPcreateExprValue(self._scip, &scipexprs[i], value, NULL, NULL) ) + * continue + * if opidx == Operator.add: # <<<<<<<<<<<<<< + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_Operator); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_add_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2270, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2271 + * continue + * if opidx == Operator.add: + * nchildren = len(node[1]) # <<<<<<<<<<<<<< + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + * coefs = malloc(nchildren * sizeof(SCIP_Real)) + */ + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = PyObject_Length(__pyx_t_7); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2271, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_nchildren = __pyx_t_10; + + /* "src/pyscipopt/scip.pxi":2272 + * if opidx == Operator.add: + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) # <<<<<<<<<<<<<< + * coefs = malloc(nchildren * sizeof(SCIP_Real)) + * for c, pos in enumerate(node[1]): + */ + __pyx_v_childrenexpr = ((SCIP_EXPR **)malloc((__pyx_v_nchildren * (sizeof(SCIP_EXPR *))))); + + /* "src/pyscipopt/scip.pxi":2273 + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + * coefs = malloc(nchildren * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * for c, pos in enumerate(node[1]): + * childrenexpr[c] = scipexprs[pos] + */ + __pyx_v_coefs = ((SCIP_Real *)malloc((__pyx_v_nchildren * (sizeof(SCIP_Real))))); + + /* "src/pyscipopt/scip.pxi":2274 + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + * coefs = malloc(nchildren * sizeof(SCIP_Real)) + * for c, pos in enumerate(node[1]): # <<<<<<<<<<<<<< + * childrenexpr[c] = scipexprs[pos] + * coefs[c] = 1 + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_7 = __pyx_int_0; + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_11 = __pyx_t_2; __Pyx_INCREF(__pyx_t_11); + __pyx_t_10 = 0; + __pyx_t_15 = NULL; + } else { + __pyx_t_10 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_15 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_11); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2274, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_15)) { + if (likely(PyList_CheckExact(__pyx_t_11))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_11); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2274, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_10); __Pyx_INCREF(__pyx_t_2); __pyx_t_10++; if (unlikely((0 < 0))) __PYX_ERR(0, 2274, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_11, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_11); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2274, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_10); __Pyx_INCREF(__pyx_t_2); __pyx_t_10++; if (unlikely((0 < 0))) __PYX_ERR(0, 2274, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_11, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_15(__pyx_t_11); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2274, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_pos, __pyx_t_2); + __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_c, __pyx_t_7); + __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_7, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2275 + * coefs = malloc(nchildren * sizeof(SCIP_Real)) + * for c, pos in enumerate(node[1]): + * childrenexpr[c] = scipexprs[pos] # <<<<<<<<<<<<<< + * coefs[c] = 1 + * PY_SCIP_CALL( SCIPcreateExprSum(self._scip, &scipexprs[i], nchildren, childrenexpr, coefs, 0, NULL, NULL)) + */ + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_v_pos); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2275, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyIndex_AsSsize_t(__pyx_v_c); if (unlikely((__pyx_t_17 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2275, __pyx_L1_error) + (__pyx_v_childrenexpr[__pyx_t_17]) = (__pyx_v_scipexprs[__pyx_t_16]); + + /* "src/pyscipopt/scip.pxi":2276 + * for c, pos in enumerate(node[1]): + * childrenexpr[c] = scipexprs[pos] + * coefs[c] = 1 # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprSum(self._scip, &scipexprs[i], nchildren, childrenexpr, coefs, 0, NULL, NULL)) + * free(coefs) + */ + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_v_c); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2276, __pyx_L1_error) + (__pyx_v_coefs[__pyx_t_16]) = 1.0; + + /* "src/pyscipopt/scip.pxi":2274 + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + * coefs = malloc(nchildren * sizeof(SCIP_Real)) + * for c, pos in enumerate(node[1]): # <<<<<<<<<<<<<< + * childrenexpr[c] = scipexprs[pos] + * coefs[c] = 1 + */ + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2277 + * childrenexpr[c] = scipexprs[pos] + * coefs[c] = 1 + * PY_SCIP_CALL( SCIPcreateExprSum(self._scip, &scipexprs[i], nchildren, childrenexpr, coefs, 0, NULL, NULL)) # <<<<<<<<<<<<<< + * free(coefs) + * free(childrenexpr) + */ + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2277, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprSum(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_10])), __pyx_v_nchildren, __pyx_v_childrenexpr, __pyx_v_coefs, 0.0, NULL, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_12 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_11, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_2}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2278 + * coefs[c] = 1 + * PY_SCIP_CALL( SCIPcreateExprSum(self._scip, &scipexprs[i], nchildren, childrenexpr, coefs, 0, NULL, NULL)) + * free(coefs) # <<<<<<<<<<<<<< + * free(childrenexpr) + * continue + */ + free(__pyx_v_coefs); + + /* "src/pyscipopt/scip.pxi":2279 + * PY_SCIP_CALL( SCIPcreateExprSum(self._scip, &scipexprs[i], nchildren, childrenexpr, coefs, 0, NULL, NULL)) + * free(coefs) + * free(childrenexpr) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.prod: + */ + free(__pyx_v_childrenexpr); + + /* "src/pyscipopt/scip.pxi":2280 + * free(coefs) + * free(childrenexpr) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.prod: + * nchildren = len(node[1]) + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2270 + * PY_SCIP_CALL( SCIPcreateExprValue(self._scip, &scipexprs[i], value, NULL, NULL) ) + * continue + * if opidx == Operator.add: # <<<<<<<<<<<<<< + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + */ + } + + /* "src/pyscipopt/scip.pxi":2281 + * free(childrenexpr) + * continue + * if opidx == Operator.prod: # <<<<<<<<<<<<<< + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_Operator); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_prod); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_11, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2281, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2281, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2282 + * continue + * if opidx == Operator.prod: + * nchildren = len(node[1]) # <<<<<<<<<<<<<< + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + * for c, pos in enumerate(node[1]): + */ + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = PyObject_Length(__pyx_t_7); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2282, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_nchildren = __pyx_t_10; + + /* "src/pyscipopt/scip.pxi":2283 + * if opidx == Operator.prod: + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) # <<<<<<<<<<<<<< + * for c, pos in enumerate(node[1]): + * childrenexpr[c] = scipexprs[pos] + */ + __pyx_v_childrenexpr = ((SCIP_EXPR **)malloc((__pyx_v_nchildren * (sizeof(SCIP_EXPR *))))); + + /* "src/pyscipopt/scip.pxi":2284 + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + * for c, pos in enumerate(node[1]): # <<<<<<<<<<<<<< + * childrenexpr[c] = scipexprs[pos] + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &scipexprs[i], nchildren, childrenexpr, 1, NULL, NULL) ) + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_7 = __pyx_int_0; + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) { + __pyx_t_2 = __pyx_t_11; __Pyx_INCREF(__pyx_t_2); + __pyx_t_10 = 0; + __pyx_t_15 = NULL; + } else { + __pyx_t_10 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_15 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2284, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + for (;;) { + if (likely(!__pyx_t_15)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2284, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_11 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_10); __Pyx_INCREF(__pyx_t_11); __pyx_t_10++; if (unlikely((0 < 0))) __PYX_ERR(0, 2284, __pyx_L1_error) + #else + __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2284, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_10); __Pyx_INCREF(__pyx_t_11); __pyx_t_10++; if (unlikely((0 < 0))) __PYX_ERR(0, 2284, __pyx_L1_error) + #else + __pyx_t_11 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + #endif + } + } else { + __pyx_t_11 = __pyx_t_15(__pyx_t_2); + if (unlikely(!__pyx_t_11)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2284, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_11); + } + __Pyx_XDECREF_SET(__pyx_v_pos, __pyx_t_11); + __pyx_t_11 = 0; + __Pyx_INCREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_c, __pyx_t_7); + __pyx_t_11 = __Pyx_PyInt_AddObjC(__pyx_t_7, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_7); + __pyx_t_7 = __pyx_t_11; + __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2285 + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + * for c, pos in enumerate(node[1]): + * childrenexpr[c] = scipexprs[pos] # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &scipexprs[i], nchildren, childrenexpr, 1, NULL, NULL) ) + * free(childrenexpr) + */ + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_v_pos); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2285, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyIndex_AsSsize_t(__pyx_v_c); if (unlikely((__pyx_t_17 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2285, __pyx_L1_error) + (__pyx_v_childrenexpr[__pyx_t_17]) = (__pyx_v_scipexprs[__pyx_t_16]); + + /* "src/pyscipopt/scip.pxi":2284 + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + * for c, pos in enumerate(node[1]): # <<<<<<<<<<<<<< + * childrenexpr[c] = scipexprs[pos] + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &scipexprs[i], nchildren, childrenexpr, 1, NULL, NULL) ) + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2286 + * for c, pos in enumerate(node[1]): + * childrenexpr[c] = scipexprs[pos] + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &scipexprs[i], nchildren, childrenexpr, 1, NULL, NULL) ) # <<<<<<<<<<<<<< + * free(childrenexpr) + * continue + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2286, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprProduct(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_10])), __pyx_v_nchildren, __pyx_v_childrenexpr, 1.0, NULL, NULL)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_11}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2287 + * childrenexpr[c] = scipexprs[pos] + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &scipexprs[i], nchildren, childrenexpr, 1, NULL, NULL) ) + * free(childrenexpr) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.power: + */ + free(__pyx_v_childrenexpr); + + /* "src/pyscipopt/scip.pxi":2288 + * PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &scipexprs[i], nchildren, childrenexpr, 1, NULL, NULL) ) + * free(childrenexpr) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.power: + * # the second child is the exponent which is a const + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2281 + * free(childrenexpr) + * continue + * if opidx == Operator.prod: # <<<<<<<<<<<<<< + * nchildren = len(node[1]) + * childrenexpr = malloc(nchildren * sizeof(SCIP_EXPR*)) + */ + } + + /* "src/pyscipopt/scip.pxi":2289 + * free(childrenexpr) + * continue + * if opidx == Operator.power: # <<<<<<<<<<<<<< + * # the second child is the exponent which is a const + * valuenode = nodes[node[1][1]] + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_Operator); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_power); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2289, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2289, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2291 + * if opidx == Operator.power: + * # the second child is the exponent which is a const + * valuenode = nodes[node[1][1]] # <<<<<<<<<<<<<< + * assert valuenode[0] == Operator.const + * exponent = valuenode[1][0] + */ + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_nodes, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_valuenode, __pyx_t_7); + __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":2292 + * # the second child is the exponent which is a const + * valuenode = nodes[node[1][1]] + * assert valuenode[0] == Operator.const # <<<<<<<<<<<<<< + * exponent = valuenode[1][0] + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], exponent, NULL, NULL )) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_valuenode, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Operator); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_const); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyObject_RichCompare(__pyx_t_7, __pyx_t_11, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2292, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2292, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2292, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2292, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2293 + * valuenode = nodes[node[1][1]] + * assert valuenode[0] == Operator.const + * exponent = valuenode[1][0] # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], exponent, NULL, NULL )) + * continue + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_valuenode, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_exponent, __pyx_t_11); + __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2294 + * assert valuenode[0] == Operator.const + * exponent = valuenode[1][0] + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], exponent, NULL, NULL )) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.exp: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2294, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_t_12); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2294, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_v_exponent); if (unlikely((__pyx_t_14 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2294, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprPow(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_10])), (__pyx_v_scipexprs[__pyx_t_16]), ((SCIP_Real)__pyx_t_14), NULL, NULL)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_12}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2295 + * exponent = valuenode[1][0] + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], exponent, NULL, NULL )) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.exp: + * assert len(node[1]) == 1 + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2289 + * free(childrenexpr) + * continue + * if opidx == Operator.power: # <<<<<<<<<<<<<< + * # the second child is the exponent which is a const + * valuenode = nodes[node[1][1]] + */ + } + + /* "src/pyscipopt/scip.pxi":2296 + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], exponent, NULL, NULL )) + * continue + * if opidx == Operator.exp: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprExp(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + */ + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_Operator); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_exp); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2296, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2296, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2296, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2297 + * continue + * if opidx == Operator.exp: + * assert len(node[1]) == 1 # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprExp(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_16 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2297, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_8 = (__pyx_t_16 == 1); + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2297, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2297, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2298 + * if opidx == Operator.exp: + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprExp(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.log: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2298, __pyx_L1_error) + __pyx_t_12 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_12, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_t_7); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2298, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprExp(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_16])), (__pyx_v_scipexprs[__pyx_t_10]), NULL, NULL)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_7}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2299 + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprExp(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.log: + * assert len(node[1]) == 1 + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2296 + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], exponent, NULL, NULL )) + * continue + * if opidx == Operator.exp: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprExp(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + */ + } + + /* "src/pyscipopt/scip.pxi":2300 + * PY_SCIP_CALL( SCIPcreateExprExp(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue + * if opidx == Operator.log: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprLog(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + */ + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_Operator); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_log); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2300, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2300, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2301 + * continue + * if opidx == Operator.log: + * assert len(node[1]) == 1 # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprLog(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_10 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2301, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_8 = (__pyx_t_10 == 1); + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2301, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2301, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2302 + * if opidx == Operator.log: + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprLog(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.sqrt: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2302, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_t_12); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2302, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprLog(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_10])), (__pyx_v_scipexprs[__pyx_t_16]), NULL, NULL)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_12}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2303 + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprLog(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.sqrt: + * assert len(node[1]) == 1 + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2300 + * PY_SCIP_CALL( SCIPcreateExprExp(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue + * if opidx == Operator.log: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprLog(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + */ + } + + /* "src/pyscipopt/scip.pxi":2304 + * PY_SCIP_CALL( SCIPcreateExprLog(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue + * if opidx == Operator.sqrt: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], 0.5, NULL, NULL) ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_Operator); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sqrt); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2304, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2304, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2305 + * continue + * if opidx == Operator.sqrt: + * assert len(node[1]) == 1 # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], 0.5, NULL, NULL) ) + * continue + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_16 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2305, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_8 = (__pyx_t_16 == 1); + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2305, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2305, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2306 + * if opidx == Operator.sqrt: + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], 0.5, NULL, NULL) ) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.sin: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2306, __pyx_L1_error) + __pyx_t_12 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_12, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_t_7); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2306, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprPow(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_16])), (__pyx_v_scipexprs[__pyx_t_10]), ((SCIP_Real)0.5), NULL, NULL)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_7}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2307 + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], 0.5, NULL, NULL) ) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.sin: + * assert len(node[1]) == 1 + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2304 + * PY_SCIP_CALL( SCIPcreateExprLog(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue + * if opidx == Operator.sqrt: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], 0.5, NULL, NULL) ) + */ + } + + /* "src/pyscipopt/scip.pxi":2308 + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], 0.5, NULL, NULL) ) + * continue + * if opidx == Operator.sin: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprSin(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_Operator); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_sin); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2308, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2308, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2309 + * continue + * if opidx == Operator.sin: + * assert len(node[1]) == 1 # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprSin(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + * continue + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2309, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_10 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2309, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_8 = (__pyx_t_10 == 1); + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2309, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2309, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2310 + * if opidx == Operator.sin: + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprSin(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.cos: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2310, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_t_12); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2310, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprSin(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_10])), (__pyx_v_scipexprs[__pyx_t_16]), NULL, NULL)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_12}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2311 + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprSin(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.cos: + * assert len(node[1]) == 1 + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2308 + * PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], 0.5, NULL, NULL) ) + * continue + * if opidx == Operator.sin: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprSin(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + */ + } + + /* "src/pyscipopt/scip.pxi":2312 + * PY_SCIP_CALL( SCIPcreateExprSin(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + * continue + * if opidx == Operator.cos: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprCos(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + */ + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_Operator); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_cos); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2312, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2312, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2313 + * continue + * if opidx == Operator.cos: + * assert len(node[1]) == 1 # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprCos(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + * continue + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_16 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_16 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2313, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_8 = (__pyx_t_16 == 1); + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2313, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2313, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2314 + * if opidx == Operator.cos: + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprCos(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) # <<<<<<<<<<<<<< + * continue + * if opidx == Operator.fabs: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2314, __pyx_L1_error) + __pyx_t_12 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_12, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_t_7); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprCos(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_16])), (__pyx_v_scipexprs[__pyx_t_10]), NULL, NULL)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_7}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2315 + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprCos(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + * continue # <<<<<<<<<<<<<< + * if opidx == Operator.fabs: + * assert len(node[1]) == 1 + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2312 + * PY_SCIP_CALL( SCIPcreateExprSin(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + * continue + * if opidx == Operator.cos: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprCos(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + */ + } + + /* "src/pyscipopt/scip.pxi":2316 + * PY_SCIP_CALL( SCIPcreateExprCos(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + * continue + * if opidx == Operator.fabs: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprAbs(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + */ + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_Operator); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_fabs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = PyObject_RichCompare(__pyx_v_opidx, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2316, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2316, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":2317 + * continue + * if opidx == Operator.fabs: + * assert len(node[1]) == 1 # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPcreateExprAbs(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_11 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_10 = PyObject_Length(__pyx_t_11); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2317, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_8 = (__pyx_t_10 == 1); + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2317, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2317, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2318 + * if opidx == Operator.fabs: + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprAbs(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) # <<<<<<<<<<<<<< + * continue + * # default: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2318, __pyx_L1_error) + __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_node, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_t_12); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2318, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateExprAbs(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_10])), (__pyx_v_scipexprs[__pyx_t_16]), NULL, NULL)); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_12}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + + /* "src/pyscipopt/scip.pxi":2319 + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprAbs(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + * continue # <<<<<<<<<<<<<< + * # default: + * raise NotImplementedError + */ + goto __pyx_L7_continue; + + /* "src/pyscipopt/scip.pxi":2316 + * PY_SCIP_CALL( SCIPcreateExprCos(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) ) + * continue + * if opidx == Operator.fabs: # <<<<<<<<<<<<<< + * assert len(node[1]) == 1 + * PY_SCIP_CALL( SCIPcreateExprAbs(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL )) + */ + } + + /* "src/pyscipopt/scip.pxi":2321 + * continue + * # default: + * raise NotImplementedError # <<<<<<<<<<<<<< + * assert varpos == nvars + * + */ + __Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0); + __PYX_ERR(0, 2321, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2256 + * varpos = 0 + * scipexprs = malloc(len(nodes) * sizeof(SCIP_EXPR*)) + * for i,node in enumerate(nodes): # <<<<<<<<<<<<<< + * opidx = node[0] + * if opidx == Operator.varidx: + */ + __pyx_L7_continue:; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2322 + * # default: + * raise NotImplementedError + * assert varpos == nvars # <<<<<<<<<<<<<< + * + * # create nonlinear constraint for the expression root + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_3 = PyObject_RichCompare(__pyx_v_varpos, __pyx_v_nvars, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2322, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_8)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2322, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2322, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2325 + * + * # create nonlinear constraint for the expression root + * PY_SCIP_CALL( SCIPcreateConsNonlinear( # <<<<<<<<<<<<<< + * self._scip, + * &scip_cons, + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "src/pyscipopt/scip.pxi":2328 + * self._scip, + * &scip_cons, + * str_conversion(kwargs['name']), # <<<<<<<<<<<<<< + * scipexprs[len(nodes) - 1], + * kwargs['lhs'], + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_12 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_name); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_12}; + __pyx_t_11 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2328, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_18 = __Pyx_PyObject_AsString(__pyx_t_11); if (unlikely((!__pyx_t_18) && PyErr_Occurred())) __PYX_ERR(0, 2328, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2329 + * &scip_cons, + * str_conversion(kwargs['name']), + * scipexprs[len(nodes) - 1], # <<<<<<<<<<<<<< + * kwargs['lhs'], + * kwargs['rhs'], + */ + __pyx_t_5 = PyObject_Length(__pyx_v_nodes); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2329, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2330 + * str_conversion(kwargs['name']), + * scipexprs[len(nodes) - 1], + * kwargs['lhs'], # <<<<<<<<<<<<<< + * kwargs['rhs'], + * kwargs['initial'], + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_lhs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_14 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_14 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2330, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2331 + * scipexprs[len(nodes) - 1], + * kwargs['lhs'], + * kwargs['rhs'], # <<<<<<<<<<<<<< + * kwargs['initial'], + * kwargs['separate'], + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_rhs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_19 = __pyx_PyFloat_AsDouble(__pyx_t_2); if (unlikely((__pyx_t_19 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2332 + * kwargs['lhs'], + * kwargs['rhs'], + * kwargs['initial'], # <<<<<<<<<<<<<< + * kwargs['separate'], + * kwargs['enforce'], + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_initial); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2332, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2333 + * kwargs['rhs'], + * kwargs['initial'], + * kwargs['separate'], # <<<<<<<<<<<<<< + * kwargs['enforce'], + * kwargs['check'], + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_separate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_21 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2334 + * kwargs['initial'], + * kwargs['separate'], + * kwargs['enforce'], # <<<<<<<<<<<<<< + * kwargs['check'], + * kwargs['propagate'], + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_enforce); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2334, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_22 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2334, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2335 + * kwargs['separate'], + * kwargs['enforce'], + * kwargs['check'], # <<<<<<<<<<<<<< + * kwargs['propagate'], + * kwargs['local'], + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_check); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_23 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_23 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2335, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2336 + * kwargs['enforce'], + * kwargs['check'], + * kwargs['propagate'], # <<<<<<<<<<<<<< + * kwargs['local'], + * kwargs['modifiable'], + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_propagate); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_24 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2336, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2337 + * kwargs['check'], + * kwargs['propagate'], + * kwargs['local'], # <<<<<<<<<<<<<< + * kwargs['modifiable'], + * kwargs['dynamic'], + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_local); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_25 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2337, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2338 + * kwargs['propagate'], + * kwargs['local'], + * kwargs['modifiable'], # <<<<<<<<<<<<<< + * kwargs['dynamic'], + * kwargs['removable']) ) + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_modifiable); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_26 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2338, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2339 + * kwargs['local'], + * kwargs['modifiable'], + * kwargs['dynamic'], # <<<<<<<<<<<<<< + * kwargs['removable']) ) + * PyCons = Constraint.create(scip_cons) + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_dynamic); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_27 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_27 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2339, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2340 + * kwargs['modifiable'], + * kwargs['dynamic'], + * kwargs['removable']) ) # <<<<<<<<<<<<<< + * PyCons = Constraint.create(scip_cons) + * for i in range(len(nodes)): + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_u_removable); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2340, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_28 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_28 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2340, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2325 + * + * # create nonlinear constraint for the expression root + * PY_SCIP_CALL( SCIPcreateConsNonlinear( # <<<<<<<<<<<<<< + * self._scip, + * &scip_cons, + */ + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsNonlinear(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_18, (__pyx_v_scipexprs[(__pyx_t_5 - 1)]), __pyx_t_14, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_t_27, __pyx_t_28)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __pyx_t_11 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2341 + * kwargs['dynamic'], + * kwargs['removable']) ) + * PyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * for i in range(len(nodes)): + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &scipexprs[i]) ) + */ + __pyx_t_3 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_PyCons = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2342 + * kwargs['removable']) ) + * PyCons = Constraint.create(scip_cons) + * for i in range(len(nodes)): # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &scipexprs[i]) ) + * + */ + __pyx_t_5 = PyObject_Length(__pyx_v_nodes); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2342, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2342, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2342, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 2342, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2342, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 2342, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_6(__pyx_t_3); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2342, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2343 + * PyCons = Constraint.create(scip_cons) + * for i in range(len(nodes)): + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &scipexprs[i]) ) # <<<<<<<<<<<<<< + * + * # free more memory + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_16 = __Pyx_PyIndex_AsSsize_t(__pyx_v_i); if (unlikely((__pyx_t_16 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2343, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseExpr(__pyx_v_self->_scip, (&(__pyx_v_scipexprs[__pyx_t_16])))); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_11}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2342 + * kwargs['removable']) ) + * PyCons = Constraint.create(scip_cons) + * for i in range(len(nodes)): # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &scipexprs[i]) ) + * + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2346 + * + * # free more memory + * free(scipexprs) # <<<<<<<<<<<<<< + * free(vars) + * + */ + free(__pyx_v_scipexprs); + + /* "src/pyscipopt/scip.pxi":2347 + * # free more memory + * free(scipexprs) + * free(vars) # <<<<<<<<<<<<<< + * + * return PyCons + */ + free(__pyx_v_vars); + + /* "src/pyscipopt/scip.pxi":2349 + * free(vars) + * + * return PyCons # <<<<<<<<<<<<<< + * + * def createConsFromExpr(self, cons, name='', initial=True, separate=True, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_PyCons); + __pyx_r = __pyx_v_PyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2230 + * return PyCons + * + * def _createConsGenNonlinear(self, cons, **kwargs): # <<<<<<<<<<<<<< + * cdef SCIP_EXPR** childrenexpr + * cdef SCIP_EXPR** scipexprs + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("pyscipopt.scip.Model._createConsGenNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_expr); + __Pyx_XDECREF(__pyx_v_nodes); + __Pyx_XDECREF(__pyx_v_nvars); + __Pyx_XDECREF(__pyx_v_node); + __Pyx_XDECREF(__pyx_v_varpos); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_opidx); + __Pyx_XDECREF(__pyx_v_pyvar); + __Pyx_XDECREF(__pyx_v_value); + __Pyx_XDECREF(__pyx_v_c); + __Pyx_XDECREF(__pyx_v_pos); + __Pyx_XDECREF(__pyx_v_valuenode); + __Pyx_XDECREF(__pyx_v_exponent); + __Pyx_XDECREF(__pyx_v_PyCons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2351 + * return PyCons + * + * def createConsFromExpr(self, cons, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_263createConsFromExpr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_262createConsFromExpr, "Model.createConsFromExpr(self, cons, name=u'', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False)\nCreate a linear or nonlinear constraint without adding it to the SCIP problem. This is useful for creating disjunction constraints\n without also enforcing the individual constituents. Currently, this can only be used as an argument to `.addConsElemDisjunction`. To add \n an individual linear/nonlinear constraint, prefer `.addCons()`.\n\n :param cons: constraint object\n :param name: the name of the constraint, generic name if empty (Default value = '')\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: should the constraint be propagated during node processing? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n :return The created @ref scip#Constraint \"Constraint\" object.\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_263createConsFromExpr = {"createConsFromExpr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_263createConsFromExpr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_262createConsFromExpr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_263createConsFromExpr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_cons = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createConsFromExpr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u__89)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2352 + * + * def createConsFromExpr(self, cons, name='', initial=True, separate=True, + * enforce=True, check=True, propagate=True, local=False, # <<<<<<<<<<<<<< + * modifiable=False, dynamic=False, removable=False, + * stickingatnode=False): + */ + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2353 + * def createConsFromExpr(self, cons, name='', initial=True, separate=True, + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, # <<<<<<<<<<<<<< + * stickingatnode=False): + * """Create a linear or nonlinear constraint without adding it to the SCIP problem. This is useful for creating disjunction constraints + */ + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2354 + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + * stickingatnode=False): # <<<<<<<<<<<<<< + * """Create a linear or nonlinear constraint without adding it to the SCIP problem. This is useful for creating disjunction constraints + * without also enforcing the individual constituents. Currently, this can only be used as an argument to `.addConsElemDisjunction`. To add + */ + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2351, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createConsFromExpr") < 0)) __PYX_ERR(0, 2351, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cons = values[0]; + __pyx_v_name = values[1]; + __pyx_v_initial = values[2]; + __pyx_v_separate = values[3]; + __pyx_v_enforce = values[4]; + __pyx_v_check = values[5]; + __pyx_v_propagate = values[6]; + __pyx_v_local = values[7]; + __pyx_v_modifiable = values[8]; + __pyx_v_dynamic = values[9]; + __pyx_v_removable = values[10]; + __pyx_v_stickingatnode = values[11]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createConsFromExpr", 0, 1, 12, __pyx_nargs); __PYX_ERR(0, 2351, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createConsFromExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_262createConsFromExpr(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_modifiable, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2351 + * return PyCons + * + * def createConsFromExpr(self, cons, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_262createConsFromExpr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + PyObject *__pyx_v_kwargs = NULL; + PyObject *__pyx_v_deg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + double __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createConsFromExpr", 0); + __Pyx_INCREF(__pyx_v_name); + + /* "src/pyscipopt/scip.pxi":2374 + * + * """ + * if name == '': # <<<<<<<<<<<<<< + * name = 'c'+str(SCIPgetNConss(self._scip)+1) + * + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_kp_u__89, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2374, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":2375 + * """ + * if name == '': + * name = 'c'+str(SCIPgetNConss(self._scip)+1) # <<<<<<<<<<<<<< + * + * kwargs = dict(name=name, initial=initial, separate=separate, + */ + __pyx_t_2 = __Pyx_PyInt_From_long((SCIPgetNConss(__pyx_v_self->_scip) + 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_Str(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyNumber_Add(__pyx_n_u_c, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2374 + * + * """ + * if name == '': # <<<<<<<<<<<<<< + * name = 'c'+str(SCIPgetNConss(self._scip)+1) + * + */ + } + + /* "src/pyscipopt/scip.pxi":2377 + * name = 'c'+str(SCIPgetNConss(self._scip)+1) + * + * kwargs = dict(name=name, initial=initial, separate=separate, # <<<<<<<<<<<<<< + * enforce=enforce, check=check, + * propagate=propagate, local=local, + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_initial, __pyx_v_initial) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_separate, __pyx_v_separate) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2378 + * + * kwargs = dict(name=name, initial=initial, separate=separate, + * enforce=enforce, check=check, # <<<<<<<<<<<<<< + * propagate=propagate, local=local, + * modifiable=modifiable, dynamic=dynamic, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_enforce, __pyx_v_enforce) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_check, __pyx_v_check) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2379 + * kwargs = dict(name=name, initial=initial, separate=separate, + * enforce=enforce, check=check, + * propagate=propagate, local=local, # <<<<<<<<<<<<<< + * modifiable=modifiable, dynamic=dynamic, + * removable=removable, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_propagate, __pyx_v_propagate) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_local, __pyx_v_local) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2380 + * enforce=enforce, check=check, + * propagate=propagate, local=local, + * modifiable=modifiable, dynamic=dynamic, # <<<<<<<<<<<<<< + * removable=removable, + * stickingatnode=stickingatnode) + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_modifiable, __pyx_v_modifiable) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dynamic, __pyx_v_dynamic) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2381 + * propagate=propagate, local=local, + * modifiable=modifiable, dynamic=dynamic, + * removable=removable, # <<<<<<<<<<<<<< + * stickingatnode=stickingatnode) + * kwargs['lhs'] = -SCIPinfinity(self._scip) if cons._lhs is None else cons._lhs + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_removable, __pyx_v_removable) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2382 + * modifiable=modifiable, dynamic=dynamic, + * removable=removable, + * stickingatnode=stickingatnode) # <<<<<<<<<<<<<< + * kwargs['lhs'] = -SCIPinfinity(self._scip) if cons._lhs is None else cons._lhs + * kwargs['rhs'] = SCIPinfinity(self._scip) if cons._rhs is None else cons._rhs + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_stickingatnode, __pyx_v_stickingatnode) < 0) __PYX_ERR(0, 2377, __pyx_L1_error) + __pyx_v_kwargs = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2383 + * removable=removable, + * stickingatnode=stickingatnode) + * kwargs['lhs'] = -SCIPinfinity(self._scip) if cons._lhs is None else cons._lhs # <<<<<<<<<<<<<< + * kwargs['rhs'] = SCIPinfinity(self._scip) if cons._rhs is None else cons._rhs + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_lhs_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = (__pyx_t_3 == Py_None); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + __pyx_t_3 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_lhs_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __pyx_t_3; + __pyx_t_3 = 0; + } + if (unlikely((PyDict_SetItem(__pyx_v_kwargs, __pyx_n_u_lhs, __pyx_t_2) < 0))) __PYX_ERR(0, 2383, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2384 + * stickingatnode=stickingatnode) + * kwargs['lhs'] = -SCIPinfinity(self._scip) if cons._lhs is None else cons._lhs + * kwargs['rhs'] = SCIPinfinity(self._scip) if cons._rhs is None else cons._rhs # <<<<<<<<<<<<<< + * + * deg = cons.expr.degree() + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_rhs_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = (__pyx_t_3 == Py_None); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + __pyx_t_3 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __pyx_t_3; + __pyx_t_3 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_rhs_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __pyx_t_3; + __pyx_t_3 = 0; + } + if (unlikely((PyDict_SetItem(__pyx_v_kwargs, __pyx_n_u_rhs, __pyx_t_2) < 0))) __PYX_ERR(0, 2384, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2386 + * kwargs['rhs'] = SCIPinfinity(self._scip) if cons._rhs is None else cons._rhs + * + * deg = cons.expr.degree() # <<<<<<<<<<<<<< + * if deg <= 1: + * return self._createConsLinear(cons, **kwargs) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_expr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_degree); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_v_deg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2387 + * + * deg = cons.expr.degree() + * if deg <= 1: # <<<<<<<<<<<<<< + * return self._createConsLinear(cons, **kwargs) + * elif deg <= 2: + */ + __pyx_t_2 = PyObject_RichCompare(__pyx_v_deg, __pyx_int_1, Py_LE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2387, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2387, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":2388 + * deg = cons.expr.degree() + * if deg <= 1: + * return self._createConsLinear(cons, **kwargs) # <<<<<<<<<<<<<< + * elif deg <= 2: + * return self._createConsQuadratic(cons, **kwargs) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createConsLinear); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_cons); + __Pyx_GIVEREF(__pyx_v_cons); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_cons)) __PYX_ERR(0, 2388, __pyx_L1_error); + __pyx_t_3 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2387 + * + * deg = cons.expr.degree() + * if deg <= 1: # <<<<<<<<<<<<<< + * return self._createConsLinear(cons, **kwargs) + * elif deg <= 2: + */ + } + + /* "src/pyscipopt/scip.pxi":2389 + * if deg <= 1: + * return self._createConsLinear(cons, **kwargs) + * elif deg <= 2: # <<<<<<<<<<<<<< + * return self._createConsQuadratic(cons, **kwargs) + * elif deg == float('inf'): # general nonlinear + */ + __pyx_t_6 = PyObject_RichCompare(__pyx_v_deg, __pyx_int_2, Py_LE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2389, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2389, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":2390 + * return self._createConsLinear(cons, **kwargs) + * elif deg <= 2: + * return self._createConsQuadratic(cons, **kwargs) # <<<<<<<<<<<<<< + * elif deg == float('inf'): # general nonlinear + * return self._createConsGenNonlinear(cons, **kwargs) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createConsQuadratic); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_cons); + __Pyx_GIVEREF(__pyx_v_cons); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_cons)) __PYX_ERR(0, 2390, __pyx_L1_error); + __pyx_t_4 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2389 + * if deg <= 1: + * return self._createConsLinear(cons, **kwargs) + * elif deg <= 2: # <<<<<<<<<<<<<< + * return self._createConsQuadratic(cons, **kwargs) + * elif deg == float('inf'): # general nonlinear + */ + } + + /* "src/pyscipopt/scip.pxi":2391 + * elif deg <= 2: + * return self._createConsQuadratic(cons, **kwargs) + * elif deg == float('inf'): # general nonlinear # <<<<<<<<<<<<<< + * return self._createConsGenNonlinear(cons, **kwargs) + * else: + */ + __pyx_t_7 = __Pyx_PyUnicode_AsDouble(__pyx_n_u_inf); if (unlikely(__pyx_t_7 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2391, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2391, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_deg, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2391, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2391, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":2392 + * return self._createConsQuadratic(cons, **kwargs) + * elif deg == float('inf'): # general nonlinear + * return self._createConsGenNonlinear(cons, **kwargs) # <<<<<<<<<<<<<< + * else: + * return self._createConsNonlinear(cons, **kwargs) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createConsGenNonlinear); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_cons); + __Pyx_GIVEREF(__pyx_v_cons); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_cons)) __PYX_ERR(0, 2392, __pyx_L1_error); + __pyx_t_3 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2391 + * elif deg <= 2: + * return self._createConsQuadratic(cons, **kwargs) + * elif deg == float('inf'): # general nonlinear # <<<<<<<<<<<<<< + * return self._createConsGenNonlinear(cons, **kwargs) + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":2394 + * return self._createConsGenNonlinear(cons, **kwargs) + * else: + * return self._createConsNonlinear(cons, **kwargs) # <<<<<<<<<<<<<< + * + * # Constraint functions + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createConsNonlinear); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_cons); + __Pyx_GIVEREF(__pyx_v_cons); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_cons)) __PYX_ERR(0, 2394, __pyx_L1_error); + __pyx_t_2 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2394, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":2351 + * return PyCons + * + * def createConsFromExpr(self, cons, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.createConsFromExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_XDECREF(__pyx_v_deg); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2397 + * + * # Constraint functions + * def addCons(self, cons, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_265addCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_264addCons, "Model.addCons(self, cons, name=u'', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False)\nAdd a linear or nonlinear constraint.\n\n :param cons: constraint object\n :param name: the name of the constraint, generic name if empty (Default value = '')\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: should the constraint be propagated during node processing? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n :return The added @ref scip#Constraint \"Constraint\" object.\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_265addCons = {"addCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_265addCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_264addCons}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_265addCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_cons = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addCons (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u__89)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2398 + * # Constraint functions + * def addCons(self, cons, name='', initial=True, separate=True, + * enforce=True, check=True, propagate=True, local=False, # <<<<<<<<<<<<<< + * modifiable=False, dynamic=False, removable=False, + * stickingatnode=False): + */ + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2399 + * def addCons(self, cons, name='', initial=True, separate=True, + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, # <<<<<<<<<<<<<< + * stickingatnode=False): + * """Add a linear or nonlinear constraint. + */ + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2400 + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + * stickingatnode=False): # <<<<<<<<<<<<<< + * """Add a linear or nonlinear constraint. + * + */ + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2397, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addCons") < 0)) __PYX_ERR(0, 2397, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cons = values[0]; + __pyx_v_name = values[1]; + __pyx_v_initial = values[2]; + __pyx_v_separate = values[3]; + __pyx_v_enforce = values[4]; + __pyx_v_check = values[5]; + __pyx_v_propagate = values[6]; + __pyx_v_local = values[7]; + __pyx_v_modifiable = values[8]; + __pyx_v_dynamic = values[9]; + __pyx_v_removable = values[10]; + __pyx_v_stickingatnode = values[11]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addCons", 0, 1, 12, __pyx_nargs); __PYX_ERR(0, 2397, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_264addCons(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_modifiable, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2397 + * + * # Constraint functions + * def addCons(self, cons, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_264addCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + SCIP_CONS *__pyx_v_scip_cons; + PyObject *__pyx_v_kwargs = NULL; + PyObject *__pyx_v_pycons_initial = NULL; + PyObject *__pyx_v_pycons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + SCIP_CONS *__pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addCons", 1); + + /* "src/pyscipopt/scip.pxi":2418 + * + * """ + * assert isinstance(cons, ExprCons), "given constraint is not ExprCons but %s" % cons.__class__.__name__ # <<<<<<<<<<<<<< + * + * cdef SCIP_CONS* scip_cons + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_cons, __pyx_ptype_9pyscipopt_4scip_ExprCons); + if (unlikely(!__pyx_t_1)) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_given_constraint_is_not_ExprCons, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_2, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2418, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2418, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2422 + * cdef SCIP_CONS* scip_cons + * + * kwargs = dict(name=name, initial=initial, separate=separate, # <<<<<<<<<<<<<< + * enforce=enforce, check=check, + * propagate=propagate, local=local, + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_initial, __pyx_v_initial) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_separate, __pyx_v_separate) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2423 + * + * kwargs = dict(name=name, initial=initial, separate=separate, + * enforce=enforce, check=check, # <<<<<<<<<<<<<< + * propagate=propagate, local=local, + * modifiable=modifiable, dynamic=dynamic, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_enforce, __pyx_v_enforce) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_check, __pyx_v_check) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2424 + * kwargs = dict(name=name, initial=initial, separate=separate, + * enforce=enforce, check=check, + * propagate=propagate, local=local, # <<<<<<<<<<<<<< + * modifiable=modifiable, dynamic=dynamic, + * removable=removable, + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_propagate, __pyx_v_propagate) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_local, __pyx_v_local) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2425 + * enforce=enforce, check=check, + * propagate=propagate, local=local, + * modifiable=modifiable, dynamic=dynamic, # <<<<<<<<<<<<<< + * removable=removable, + * stickingatnode=stickingatnode) + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_modifiable, __pyx_v_modifiable) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dynamic, __pyx_v_dynamic) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2426 + * propagate=propagate, local=local, + * modifiable=modifiable, dynamic=dynamic, + * removable=removable, # <<<<<<<<<<<<<< + * stickingatnode=stickingatnode) + * # we have to pass this back to a SCIP_CONS* + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_removable, __pyx_v_removable) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2427 + * modifiable=modifiable, dynamic=dynamic, + * removable=removable, + * stickingatnode=stickingatnode) # <<<<<<<<<<<<<< + * # we have to pass this back to a SCIP_CONS* + * # object to create a new python constraint & handle constraint release + */ + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_stickingatnode, __pyx_v_stickingatnode) < 0) __PYX_ERR(0, 2422, __pyx_L1_error) + __pyx_v_kwargs = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2432 + * # correctly. Otherwise, segfaults when trying to query information + * # about the created constraint later. + * pycons_initial = self.createConsFromExpr(cons, **kwargs) # <<<<<<<<<<<<<< + * scip_cons = (pycons_initial).scip_cons + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createConsFromExpr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_cons); + __Pyx_GIVEREF(__pyx_v_cons); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_cons)) __PYX_ERR(0, 2432, __pyx_L1_error); + __pyx_t_4 = PyDict_Copy(__pyx_v_kwargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_pycons_initial = __pyx_t_5; + __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2433 + * # about the created constraint later. + * pycons_initial = self.createConsFromExpr(cons, **kwargs) + * scip_cons = (pycons_initial).scip_cons # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + */ + __pyx_t_6 = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_pycons_initial)->scip_cons; + __pyx_v_scip_cons = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":2435 + * scip_cons = (pycons_initial).scip_cons + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) # <<<<<<<<<<<<<< + * pycons = Constraint.create(scip_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_scip_cons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2435, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2436 + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pycons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + */ + __pyx_t_5 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_pycons = __pyx_t_5; + __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2437 + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pycons = Constraint.create(scip_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) # <<<<<<<<<<<<<< + * + * return pycons + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&__pyx_v_scip_cons))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2439 + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + * return pycons # <<<<<<<<<<<<<< + * + * def addConss(self, conss, name='', initial=True, separate=True, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pycons); + __pyx_r = __pyx_v_pycons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2397 + * + * # Constraint functions + * def addCons(self, cons, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_XDECREF(__pyx_v_pycons_initial); + __Pyx_XDECREF(__pyx_v_pycons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2441 + * return pycons + * + * def addConss(self, conss, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_267addConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_266addConss, "Model.addConss(self, conss, name=u'', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False)\nAdds multiple linear or quadratic constraints.\n\n Each of the constraints is added to the model using Model.addCons().\n\n For all parameters, except @p conss, this method behaves differently depending on the type of the passed argument:\n 1. If the value is iterable, it must be of the same length as @p conss. For each constraint, Model.addCons() will be called with the value at the corresponding index.\n 2. Else, the (default) value will be applied to all of the constraints.\n\n :param conss An iterable of constraint objects. Any iterable will be converted into a list before further processing.\n :param name: the names of the constraints, generic name if empty (Default value = ''). If a single string is passed, it will be suffixed by an underscore and the enumerated index of the constraint (starting with 0).\n :param initial: should the LP relaxation of constraints be in the initial LP? (Default value = True)\n :param separate: should the constraints be separated during LP processing? (Default value = True)\n :param enforce: should the constraints be enforced during node processing? (Default value = True)\n :param check: should the constraints be checked for feasibility? (Default value = True)\n :param propagate: should the constraints be propagated during node processing? (Default value = True)\n :param local: are the constraints only valid locally? (Default value = False)\n :param modifiable: are the constraints modifiable (subject to column generation)? (Default value = False)\n :param dynamic: are the constraints subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = Fa""lse)\n :param stickingatnode: should the constraints always be kept at the node where it was added, even if it may be @oved to a more global node? (Default value = False)\n :return A list of added @ref scip#Constraint \"Constraint\" objects.\n\n :see addCons()\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_267addConss = {"addConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_267addConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_266addConss}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_267addConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_conss = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConss (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conss,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u__89)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2442 + * + * def addConss(self, conss, name='', initial=True, separate=True, + * enforce=True, check=True, propagate=True, local=False, # <<<<<<<<<<<<<< + * modifiable=False, dynamic=False, removable=False, + * stickingatnode=False): + */ + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2443 + * def addConss(self, conss, name='', initial=True, separate=True, + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, # <<<<<<<<<<<<<< + * stickingatnode=False): + * """Adds multiple linear or quadratic constraints. + */ + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2444 + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + * stickingatnode=False): # <<<<<<<<<<<<<< + * """Adds multiple linear or quadratic constraints. + * + */ + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_conss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2441, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConss") < 0)) __PYX_ERR(0, 2441, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_conss = values[0]; + __pyx_v_name = values[1]; + __pyx_v_initial = values[2]; + __pyx_v_separate = values[3]; + __pyx_v_enforce = values[4]; + __pyx_v_check = values[5]; + __pyx_v_propagate = values[6]; + __pyx_v_local = values[7]; + __pyx_v_modifiable = values[8]; + __pyx_v_dynamic = values[9]; + __pyx_v_removable = values[10]; + __pyx_v_stickingatnode = values[11]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConss", 0, 1, 12, __pyx_nargs); __PYX_ERR(0, 2441, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_266addConss(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_conss, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_modifiable, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2441 + * return pycons + * + * def addConss(self, conss, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2469 + * :see addCons() + * """ + * def ensure_iterable(elem, length): # <<<<<<<<<<<<<< + * if isinstance(elem, Iterable): + * return elem + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_8addConss_1ensure_iterable(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_8addConss_1ensure_iterable = {"ensure_iterable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_8addConss_1ensure_iterable, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_8addConss_1ensure_iterable(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_elem = 0; + PyObject *__pyx_v_length = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ensure_iterable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_elem,&__pyx_n_s_length,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_elem)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2469, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_length)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2469, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("ensure_iterable", 1, 2, 2, 1); __PYX_ERR(0, 2469, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ensure_iterable") < 0)) __PYX_ERR(0, 2469, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_elem = values[0]; + __pyx_v_length = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ensure_iterable", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2469, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConss.ensure_iterable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_self, __pyx_v_elem, __pyx_v_length); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_elem, PyObject *__pyx_v_length) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ensure_iterable", 1); + + /* "src/pyscipopt/scip.pxi":2470 + * """ + * def ensure_iterable(elem, length): + * if isinstance(elem, Iterable): # <<<<<<<<<<<<<< + * return elem + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Iterable); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2470, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_elem, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 2470, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":2471 + * def ensure_iterable(elem, length): + * if isinstance(elem, Iterable): + * return elem # <<<<<<<<<<<<<< + * else: + * return list(repeat(elem, length)) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_elem); + __pyx_r = __pyx_v_elem; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2470 + * """ + * def ensure_iterable(elem, length): + * if isinstance(elem, Iterable): # <<<<<<<<<<<<<< + * return elem + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":2473 + * return elem + * else: + * return list(repeat(elem, length)) # <<<<<<<<<<<<<< + * + * assert isinstance(conss, Iterable), "Given constraint list is not iterable." + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_repeat); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_elem, __pyx_v_length}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_PySequence_ListKeepNew(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2473, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":2469 + * :see addCons() + * """ + * def ensure_iterable(elem, length): # <<<<<<<<<<<<<< + * if isinstance(elem, Iterable): + * return elem + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConss.ensure_iterable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2441 + * return pycons + * + * def addConss(self, conss, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_266addConss(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_conss, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + PyObject *__pyx_v_ensure_iterable = 0; + Py_ssize_t __pyx_v_n_conss; + PyObject *__pyx_v_constraints = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_cons = NULL; + CYTHON_UNUSED Py_ssize_t __pyx_9genexpr37__pyx_v_idx; + Py_ssize_t __pyx_9genexpr38__pyx_v_idx; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + Py_UCS4 __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + PyObject *__pyx_t_16 = NULL; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + PyObject *__pyx_t_23 = NULL; + int __pyx_t_24; + int __pyx_t_25; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConss", 0); + __Pyx_INCREF(__pyx_v_conss); + __Pyx_INCREF(__pyx_v_name); + __Pyx_INCREF(__pyx_v_initial); + __Pyx_INCREF(__pyx_v_separate); + __Pyx_INCREF(__pyx_v_enforce); + __Pyx_INCREF(__pyx_v_check); + __Pyx_INCREF(__pyx_v_propagate); + __Pyx_INCREF(__pyx_v_local); + __Pyx_INCREF(__pyx_v_modifiable); + __Pyx_INCREF(__pyx_v_dynamic); + __Pyx_INCREF(__pyx_v_removable); + __Pyx_INCREF(__pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2469 + * :see addCons() + * """ + * def ensure_iterable(elem, length): # <<<<<<<<<<<<<< + * if isinstance(elem, Iterable): + * return elem + */ + __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_8addConss_1ensure_iterable, 0, __pyx_n_s_addConss_locals_ensure_iterable, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__93)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_ensure_iterable = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2475 + * return list(repeat(elem, length)) + * + * assert isinstance(conss, Iterable), "Given constraint list is not iterable." # <<<<<<<<<<<<<< + * + * conss = list(conss) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Iterable); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_conss, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 2475, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_Given_constraint_list_is_not_ite, 0, 0); + __PYX_ERR(0, 2475, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2475, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2477 + * assert isinstance(conss, Iterable), "Given constraint list is not iterable." + * + * conss = list(conss) # <<<<<<<<<<<<<< + * n_conss = len(conss) + * + */ + __pyx_t_1 = PySequence_List(__pyx_v_conss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_conss, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2478 + * + * conss = list(conss) + * n_conss = len(conss) # <<<<<<<<<<<<<< + * + * if isinstance(name, str): + */ + __pyx_t_3 = PyObject_Length(__pyx_v_conss); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2478, __pyx_L1_error) + __pyx_v_n_conss = __pyx_t_3; + + /* "src/pyscipopt/scip.pxi":2480 + * n_conss = len(conss) + * + * if isinstance(name, str): # <<<<<<<<<<<<<< + * if name == "": + * name = ["" for idx in range(n_conss)] + */ + __pyx_t_2 = PyUnicode_Check(__pyx_v_name); + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":2481 + * + * if isinstance(name, str): + * if name == "": # <<<<<<<<<<<<<< + * name = ["" for idx in range(n_conss)] + * else: + */ + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_name, __pyx_kp_u__89, Py_EQ)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 2481, __pyx_L1_error) + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":2482 + * if isinstance(name, str): + * if name == "": + * name = ["" for idx in range(n_conss)] # <<<<<<<<<<<<<< + * else: + * name = ["%s_%s" % (name, idx) for idx in range(n_conss)] + */ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_v_n_conss; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_9genexpr37__pyx_v_idx = __pyx_t_5; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_kp_u__89))) __PYX_ERR(0, 2482, __pyx_L1_error) + } + } /* exit inner scope */ + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2481 + * + * if isinstance(name, str): + * if name == "": # <<<<<<<<<<<<<< + * name = ["" for idx in range(n_conss)] + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":2484 + * name = ["" for idx in range(n_conss)] + * else: + * name = ["%s_%s" % (name, idx) for idx in range(n_conss)] # <<<<<<<<<<<<<< + * initial = ensure_iterable(initial, n_conss) + * separate = ensure_iterable(separate, n_conss) + */ + /*else*/ { + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_v_n_conss; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_9genexpr38__pyx_v_idx = __pyx_t_5; + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_8 = 127; + __pyx_t_9 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Unicode(__pyx_v_name), __pyx_empty_unicode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) > __pyx_t_8) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_9) : __pyx_t_8; + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_9); + __pyx_t_9 = 0; + __Pyx_INCREF(__pyx_n_u__94); + __pyx_t_7 += 1; + __Pyx_GIVEREF(__pyx_n_u__94); + PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_n_u__94); + __pyx_t_9 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_9genexpr38__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_9); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2484, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_9))) __PYX_ERR(0, 2484, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + } /* exit inner scope */ + __Pyx_DECREF_SET(__pyx_v_name, __pyx_t_1); + __pyx_t_1 = 0; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":2480 + * n_conss = len(conss) + * + * if isinstance(name, str): # <<<<<<<<<<<<<< + * if name == "": + * name = ["" for idx in range(n_conss)] + */ + } + + /* "src/pyscipopt/scip.pxi":2485 + * else: + * name = ["%s_%s" % (name, idx) for idx in range(n_conss)] + * initial = ensure_iterable(initial, n_conss) # <<<<<<<<<<<<<< + * separate = ensure_iterable(separate, n_conss) + * enforce = ensure_iterable(enforce, n_conss) + */ + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_initial, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_initial, __pyx_t_9); + __pyx_t_9 = 0; + + /* "src/pyscipopt/scip.pxi":2486 + * name = ["%s_%s" % (name, idx) for idx in range(n_conss)] + * initial = ensure_iterable(initial, n_conss) + * separate = ensure_iterable(separate, n_conss) # <<<<<<<<<<<<<< + * enforce = ensure_iterable(enforce, n_conss) + * check = ensure_iterable(check, n_conss) + */ + __pyx_t_9 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_separate, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_separate, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2487 + * initial = ensure_iterable(initial, n_conss) + * separate = ensure_iterable(separate, n_conss) + * enforce = ensure_iterable(enforce, n_conss) # <<<<<<<<<<<<<< + * check = ensure_iterable(check, n_conss) + * propagate = ensure_iterable(propagate, n_conss) + */ + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_enforce, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2487, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_enforce, __pyx_t_9); + __pyx_t_9 = 0; + + /* "src/pyscipopt/scip.pxi":2488 + * separate = ensure_iterable(separate, n_conss) + * enforce = ensure_iterable(enforce, n_conss) + * check = ensure_iterable(check, n_conss) # <<<<<<<<<<<<<< + * propagate = ensure_iterable(propagate, n_conss) + * local = ensure_iterable(local, n_conss) + */ + __pyx_t_9 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_check, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_check, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2489 + * enforce = ensure_iterable(enforce, n_conss) + * check = ensure_iterable(check, n_conss) + * propagate = ensure_iterable(propagate, n_conss) # <<<<<<<<<<<<<< + * local = ensure_iterable(local, n_conss) + * modifiable = ensure_iterable(modifiable, n_conss) + */ + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_propagate, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_propagate, __pyx_t_9); + __pyx_t_9 = 0; + + /* "src/pyscipopt/scip.pxi":2490 + * check = ensure_iterable(check, n_conss) + * propagate = ensure_iterable(propagate, n_conss) + * local = ensure_iterable(local, n_conss) # <<<<<<<<<<<<<< + * modifiable = ensure_iterable(modifiable, n_conss) + * dynamic = ensure_iterable(dynamic, n_conss) + */ + __pyx_t_9 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_local, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_local, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2491 + * propagate = ensure_iterable(propagate, n_conss) + * local = ensure_iterable(local, n_conss) + * modifiable = ensure_iterable(modifiable, n_conss) # <<<<<<<<<<<<<< + * dynamic = ensure_iterable(dynamic, n_conss) + * removable = ensure_iterable(removable, n_conss) + */ + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_modifiable, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_modifiable, __pyx_t_9); + __pyx_t_9 = 0; + + /* "src/pyscipopt/scip.pxi":2492 + * local = ensure_iterable(local, n_conss) + * modifiable = ensure_iterable(modifiable, n_conss) + * dynamic = ensure_iterable(dynamic, n_conss) # <<<<<<<<<<<<<< + * removable = ensure_iterable(removable, n_conss) + * stickingatnode = ensure_iterable(stickingatnode, n_conss) + */ + __pyx_t_9 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2492, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_dynamic, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2492, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_dynamic, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2493 + * modifiable = ensure_iterable(modifiable, n_conss) + * dynamic = ensure_iterable(dynamic, n_conss) + * removable = ensure_iterable(removable, n_conss) # <<<<<<<<<<<<<< + * stickingatnode = ensure_iterable(stickingatnode, n_conss) + * + */ + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_removable, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_removable, __pyx_t_9); + __pyx_t_9 = 0; + + /* "src/pyscipopt/scip.pxi":2494 + * dynamic = ensure_iterable(dynamic, n_conss) + * removable = ensure_iterable(removable, n_conss) + * stickingatnode = ensure_iterable(stickingatnode, n_conss) # <<<<<<<<<<<<<< + * + * constraints = [] + */ + __pyx_t_9 = PyInt_FromSsize_t(__pyx_v_n_conss); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __pyx_pf_9pyscipopt_4scip_5Model_8addConss_ensure_iterable(__pyx_v_ensure_iterable, __pyx_v_stickingatnode, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF_SET(__pyx_v_stickingatnode, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2496 + * stickingatnode = ensure_iterable(stickingatnode, n_conss) + * + * constraints = [] # <<<<<<<<<<<<<< + * for i, cons in enumerate(conss): + * constraints.append( + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraints = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2497 + * + * constraints = [] + * for i, cons in enumerate(conss): # <<<<<<<<<<<<<< + * constraints.append( + * self.addCons(cons, name[i], initial[i], separate[i], enforce[i], + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_1 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_conss)) || PyTuple_CheckExact(__pyx_v_conss)) { + __pyx_t_9 = __pyx_v_conss; __Pyx_INCREF(__pyx_t_9); + __pyx_t_3 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_v_conss); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2497, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_9))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_9); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2497, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_9, __pyx_t_3); __Pyx_INCREF(__pyx_t_6); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 2497, __pyx_L1_error) + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_9); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2497, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_3); __Pyx_INCREF(__pyx_t_6); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 2497, __pyx_L1_error) + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_9, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } + } else { + __pyx_t_6 = __pyx_t_10(__pyx_t_9); + if (unlikely(!__pyx_t_6)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2497, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_6); + } + __Pyx_XDECREF_SET(__pyx_v_cons, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2499 + * for i, cons in enumerate(conss): + * constraints.append( + * self.addCons(cons, name[i], initial[i], separate[i], enforce[i], # <<<<<<<<<<<<<< + * check[i], propagate[i], local[i], modifiable[i], + * dynamic[i], removable[i], stickingatnode[i]) + */ + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_addCons); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyObject_GetItem(__pyx_v_name, __pyx_v_i); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_13 = __Pyx_PyObject_GetItem(__pyx_v_initial, __pyx_v_i); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = __Pyx_PyObject_GetItem(__pyx_v_separate, __pyx_v_i); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = __Pyx_PyObject_GetItem(__pyx_v_enforce, __pyx_v_i); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 2499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + + /* "src/pyscipopt/scip.pxi":2500 + * constraints.append( + * self.addCons(cons, name[i], initial[i], separate[i], enforce[i], + * check[i], propagate[i], local[i], modifiable[i], # <<<<<<<<<<<<<< + * dynamic[i], removable[i], stickingatnode[i]) + * ) + */ + __pyx_t_16 = __Pyx_PyObject_GetItem(__pyx_v_check, __pyx_v_i); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_16); + __pyx_t_17 = __Pyx_PyObject_GetItem(__pyx_v_propagate, __pyx_v_i); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_18 = __Pyx_PyObject_GetItem(__pyx_v_local, __pyx_v_i); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 2500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_19 = __Pyx_PyObject_GetItem(__pyx_v_modifiable, __pyx_v_i); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 2500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + + /* "src/pyscipopt/scip.pxi":2501 + * self.addCons(cons, name[i], initial[i], separate[i], enforce[i], + * check[i], propagate[i], local[i], modifiable[i], + * dynamic[i], removable[i], stickingatnode[i]) # <<<<<<<<<<<<<< + * ) + * + */ + __pyx_t_20 = __Pyx_PyObject_GetItem(__pyx_v_dynamic, __pyx_v_i); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 2501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __pyx_t_21 = __Pyx_PyObject_GetItem(__pyx_v_removable, __pyx_v_i); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 2501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_22 = __Pyx_PyObject_GetItem(__pyx_v_stickingatnode, __pyx_v_i); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_23 = NULL; + __pyx_t_24 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_11); + if (likely(__pyx_t_23)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_23); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_11, function); + __pyx_t_24 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[13] = {__pyx_t_23, __pyx_v_cons, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+1-__pyx_t_24, 12+__pyx_t_24); + __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + } + + /* "src/pyscipopt/scip.pxi":2498 + * constraints = [] + * for i, cons in enumerate(conss): + * constraints.append( # <<<<<<<<<<<<<< + * self.addCons(cons, name[i], initial[i], separate[i], enforce[i], + * check[i], propagate[i], local[i], modifiable[i], + */ + __pyx_t_25 = __Pyx_PyList_Append(__pyx_v_constraints, __pyx_t_6); if (unlikely(__pyx_t_25 == ((int)-1))) __PYX_ERR(0, 2498, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2497 + * + * constraints = [] + * for i, cons in enumerate(conss): # <<<<<<<<<<<<<< + * constraints.append( + * self.addCons(cons, name[i], initial[i], separate[i], enforce[i], + */ + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2504 + * ) + * + * return constraints # <<<<<<<<<<<<<< + * + * def addConsDisjunction(self, conss, name = '', initial = True, + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_constraints); + __pyx_r = __pyx_v_constraints; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2441 + * return pycons + * + * def addConss(self, conss, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_XDECREF(__pyx_t_16); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + __Pyx_XDECREF(__pyx_t_20); + __Pyx_XDECREF(__pyx_t_21); + __Pyx_XDECREF(__pyx_t_22); + __Pyx_XDECREF(__pyx_t_23); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ensure_iterable); + __Pyx_XDECREF(__pyx_v_constraints); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_cons); + __Pyx_XDECREF(__pyx_v_conss); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_initial); + __Pyx_XDECREF(__pyx_v_separate); + __Pyx_XDECREF(__pyx_v_enforce); + __Pyx_XDECREF(__pyx_v_check); + __Pyx_XDECREF(__pyx_v_propagate); + __Pyx_XDECREF(__pyx_v_local); + __Pyx_XDECREF(__pyx_v_modifiable); + __Pyx_XDECREF(__pyx_v_dynamic); + __Pyx_XDECREF(__pyx_v_removable); + __Pyx_XDECREF(__pyx_v_stickingatnode); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2506 + * return constraints + * + * def addConsDisjunction(self, conss, name = '', initial = True, # <<<<<<<<<<<<<< + * relaxcons = None, enforce=True, check =True, + * local=False, modifiable = False, dynamic = False): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_269addConsDisjunction(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_268addConsDisjunction, "Model.addConsDisjunction(self, conss, name=u'', initial=True, relaxcons=None, enforce=True, check=True, local=False, modifiable=False, dynamic=False)\nAdd a disjunction constraint.\n\n :param Iterable[Constraint] conss: An iterable of constraint objects to be included initially in the disjunction. Currently, these must be expressions.\n :param name: the name of the disjunction constraint.\n :param initial: should the LP relaxation of disjunction constraint be in the initial LP? (Default value = True)\n :param relaxcons: a conjunction constraint containing the linear relaxation of the disjunction constraint, or None. (Default value = None)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :return The added @ref scip#Constraint \"Constraint\" object.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_269addConsDisjunction = {"addConsDisjunction", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_269addConsDisjunction, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_268addConsDisjunction}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_269addConsDisjunction(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_conss = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + CYTHON_UNUSED PyObject *__pyx_v_relaxcons = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_dynamic = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[9] = {0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsDisjunction (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conss,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_relaxcons,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_dynamic,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u__89)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2507 + * + * def addConsDisjunction(self, conss, name = '', initial = True, + * relaxcons = None, enforce=True, check =True, # <<<<<<<<<<<<<< + * local=False, modifiable = False, dynamic = False): + * """Add a disjunction constraint. + */ + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2508 + * def addConsDisjunction(self, conss, name = '', initial = True, + * relaxcons = None, enforce=True, check =True, + * local=False, modifiable = False, dynamic = False): # <<<<<<<<<<<<<< + * """Add a disjunction constraint. + * + */ + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_conss)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_relaxcons); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2506, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsDisjunction") < 0)) __PYX_ERR(0, 2506, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_conss = values[0]; + __pyx_v_name = values[1]; + __pyx_v_initial = values[2]; + __pyx_v_relaxcons = values[3]; + __pyx_v_enforce = values[4]; + __pyx_v_check = values[5]; + __pyx_v_local = values[6]; + __pyx_v_modifiable = values[7]; + __pyx_v_dynamic = values[8]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsDisjunction", 0, 1, 9, __pyx_nargs); __PYX_ERR(0, 2506, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsDisjunction", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_268addConsDisjunction(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_conss, __pyx_v_name, __pyx_v_initial, __pyx_v_relaxcons, __pyx_v_enforce, __pyx_v_check, __pyx_v_local, __pyx_v_modifiable, __pyx_v_dynamic); + + /* "src/pyscipopt/scip.pxi":2506 + * return constraints + * + * def addConsDisjunction(self, conss, name = '', initial = True, # <<<<<<<<<<<<<< + * relaxcons = None, enforce=True, check =True, + * local=False, modifiable = False, dynamic = False): + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2522 + * :return The added @ref scip#Constraint "Constraint" object. + * """ + * def ensure_iterable(elem, length): # <<<<<<<<<<<<<< + * if isinstance(elem, Iterable): + * return elem + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_18addConsDisjunction_1ensure_iterable(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_18addConsDisjunction_1ensure_iterable = {"ensure_iterable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_18addConsDisjunction_1ensure_iterable, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_18addConsDisjunction_1ensure_iterable(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_elem = 0; + PyObject *__pyx_v_length = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ensure_iterable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_elem,&__pyx_n_s_length,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_elem)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2522, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_length)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2522, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("ensure_iterable", 1, 2, 2, 1); __PYX_ERR(0, 2522, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ensure_iterable") < 0)) __PYX_ERR(0, 2522, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_elem = values[0]; + __pyx_v_length = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ensure_iterable", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2522, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsDisjunction.ensure_iterable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_18addConsDisjunction_ensure_iterable(__pyx_self, __pyx_v_elem, __pyx_v_length); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_18addConsDisjunction_ensure_iterable(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_elem, PyObject *__pyx_v_length) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ensure_iterable", 1); + + /* "src/pyscipopt/scip.pxi":2523 + * """ + * def ensure_iterable(elem, length): + * if isinstance(elem, Iterable): # <<<<<<<<<<<<<< + * return elem + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Iterable); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_elem, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 2523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":2524 + * def ensure_iterable(elem, length): + * if isinstance(elem, Iterable): + * return elem # <<<<<<<<<<<<<< + * else: + * return list(repeat(elem, length)) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_elem); + __pyx_r = __pyx_v_elem; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2523 + * """ + * def ensure_iterable(elem, length): + * if isinstance(elem, Iterable): # <<<<<<<<<<<<<< + * return elem + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":2526 + * return elem + * else: + * return list(repeat(elem, length)) # <<<<<<<<<<<<<< + * assert isinstance(conss, Iterable), "Given constraint list is not iterable" + * + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_repeat); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_v_elem, __pyx_v_length}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_PySequence_ListKeepNew(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":2522 + * :return The added @ref scip#Constraint "Constraint" object. + * """ + * def ensure_iterable(elem, length): # <<<<<<<<<<<<<< + * if isinstance(elem, Iterable): + * return elem + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsDisjunction.ensure_iterable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2506 + * return constraints + * + * def addConsDisjunction(self, conss, name = '', initial = True, # <<<<<<<<<<<<<< + * relaxcons = None, enforce=True, check =True, + * local=False, modifiable = False, dynamic = False): + */ + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_268addConsDisjunction(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_conss, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, CYTHON_UNUSED PyObject *__pyx_v_relaxcons, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic) { + CYTHON_UNUSED PyObject *__pyx_v_ensure_iterable = 0; + CYTHON_UNUSED Py_ssize_t __pyx_v_n_conss; + SCIP_CONS *__pyx_v_disj_cons; + SCIP_CONS *__pyx_v_scip_cons; + CYTHON_UNUSED PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_cons = NULL; + PyObject *__pyx_v_pycons = NULL; + PyObject *__pyx_v_PyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + char const *__pyx_t_9; + SCIP_Bool __pyx_t_10; + SCIP_Bool __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + PyObject *(*__pyx_t_16)(PyObject *); + PyObject *__pyx_t_17 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsDisjunction", 0); + __Pyx_INCREF(__pyx_v_conss); + + /* "src/pyscipopt/scip.pxi":2522 + * :return The added @ref scip#Constraint "Constraint" object. + * """ + * def ensure_iterable(elem, length): # <<<<<<<<<<<<<< + * if isinstance(elem, Iterable): + * return elem + */ + __pyx_t_1 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_18addConsDisjunction_1ensure_iterable, 0, __pyx_n_s_addConsDisjunction_locals_ensure, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__95)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_ensure_iterable = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2527 + * else: + * return list(repeat(elem, length)) + * assert isinstance(conss, Iterable), "Given constraint list is not iterable" # <<<<<<<<<<<<<< + * + * conss = list(conss) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_Iterable); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyObject_IsInstance(__pyx_v_conss, __pyx_t_1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 2527, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_Given_constraint_list_is_not_ite_2, 0, 0); + __PYX_ERR(0, 2527, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2527, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2529 + * assert isinstance(conss, Iterable), "Given constraint list is not iterable" + * + * conss = list(conss) # <<<<<<<<<<<<<< + * n_conss = len(conss) + * + */ + __pyx_t_1 = PySequence_List(__pyx_v_conss); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF_SET(__pyx_v_conss, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2530 + * + * conss = list(conss) + * n_conss = len(conss) # <<<<<<<<<<<<<< + * + * cdef SCIP_CONS* disj_cons + */ + __pyx_t_3 = PyObject_Length(__pyx_v_conss); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2530, __pyx_L1_error) + __pyx_v_n_conss = __pyx_t_3; + + /* "src/pyscipopt/scip.pxi":2538 + * cdef SCIP_EXPR* scip_expr + * + * PY_SCIP_CALL(SCIPcreateConsDisjunction( # <<<<<<<<<<<<<< + * self._scip, &disj_cons, str_conversion(name), 0, &scip_cons, NULL, + * initial, enforce, check, local, modifiable, dynamic + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "src/pyscipopt/scip.pxi":2539 + * + * PY_SCIP_CALL(SCIPcreateConsDisjunction( + * self._scip, &disj_cons, str_conversion(name), 0, &scip_cons, NULL, # <<<<<<<<<<<<<< + * initial, enforce, check, local, modifiable, dynamic + * )) + */ + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_name}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_9 = __Pyx_PyObject_AsString(__pyx_t_5); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(0, 2539, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2540 + * PY_SCIP_CALL(SCIPcreateConsDisjunction( + * self._scip, &disj_cons, str_conversion(name), 0, &scip_cons, NULL, + * initial, enforce, check, local, modifiable, dynamic # <<<<<<<<<<<<<< + * )) + * + */ + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2540, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2540, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2540, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2540, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_modifiable); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2540, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2540, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2538 + * cdef SCIP_EXPR* scip_expr + * + * PY_SCIP_CALL(SCIPcreateConsDisjunction( # <<<<<<<<<<<<<< + * self._scip, &disj_cons, str_conversion(name), 0, &scip_cons, NULL, + * initial, enforce, check, local, modifiable, dynamic + */ + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsDisjunction(__pyx_v_self->_scip, (&__pyx_v_disj_cons), __pyx_t_9, 0, (&__pyx_v_scip_cons), NULL, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2538, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2545 + * + * # TODO add constraints to disjunction + * for i, cons in enumerate(conss): # <<<<<<<<<<<<<< + * pycons = self.createConsFromExpr(cons, name=name, initial = initial, + * enforce=enforce, check=check, + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_1 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_conss)) || PyTuple_CheckExact(__pyx_v_conss)) { + __pyx_t_4 = __pyx_v_conss; __Pyx_INCREF(__pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_16 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_conss); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_16 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 2545, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_16)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2545, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_3); __Pyx_INCREF(__pyx_t_6); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 2545, __pyx_L1_error) + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2545, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_3); __Pyx_INCREF(__pyx_t_6); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 2545, __pyx_L1_error) + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } + } else { + __pyx_t_6 = __pyx_t_16(__pyx_t_4); + if (unlikely(!__pyx_t_6)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2545, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_6); + } + __Pyx_XDECREF_SET(__pyx_v_cons, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2546 + * # TODO add constraints to disjunction + * for i, cons in enumerate(conss): + * pycons = self.createConsFromExpr(cons, name=name, initial = initial, # <<<<<<<<<<<<<< + * enforce=enforce, check=check, + * local=local, modifiable=modifiable, dynamic=dynamic + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createConsFromExpr); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_cons); + __Pyx_GIVEREF(__pyx_v_cons); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_cons)) __PYX_ERR(0, 2546, __pyx_L1_error); + __pyx_t_7 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_name, __pyx_v_name) < 0) __PYX_ERR(0, 2546, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_initial, __pyx_v_initial) < 0) __PYX_ERR(0, 2546, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2547 + * for i, cons in enumerate(conss): + * pycons = self.createConsFromExpr(cons, name=name, initial = initial, + * enforce=enforce, check=check, # <<<<<<<<<<<<<< + * local=local, modifiable=modifiable, dynamic=dynamic + * ) + */ + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_enforce, __pyx_v_enforce) < 0) __PYX_ERR(0, 2546, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_check, __pyx_v_check) < 0) __PYX_ERR(0, 2546, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2548 + * pycons = self.createConsFromExpr(cons, name=name, initial = initial, + * enforce=enforce, check=check, + * local=local, modifiable=modifiable, dynamic=dynamic # <<<<<<<<<<<<<< + * ) + * PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip,disj_cons, (pycons).scip_cons)) + */ + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_local, __pyx_v_local) < 0) __PYX_ERR(0, 2546, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_modifiable, __pyx_v_modifiable) < 0) __PYX_ERR(0, 2546, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dynamic, __pyx_v_dynamic) < 0) __PYX_ERR(0, 2546, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2546 + * # TODO add constraints to disjunction + * for i, cons in enumerate(conss): + * pycons = self.createConsFromExpr(cons, name=name, initial = initial, # <<<<<<<<<<<<<< + * enforce=enforce, check=check, + * local=local, modifiable=modifiable, dynamic=dynamic + */ + __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2546, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_v_pycons, __pyx_t_17); + __pyx_t_17 = 0; + + /* "src/pyscipopt/scip.pxi":2550 + * local=local, modifiable=modifiable, dynamic=dynamic + * ) + * PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip,disj_cons, (pycons).scip_cons)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(pycons).scip_cons)) + * PY_SCIP_CALL(SCIPaddCons(self._scip, disj_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddConsElemDisjunction(__pyx_v_self->_scip, __pyx_v_disj_cons, ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_pycons)->scip_cons)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + + /* "src/pyscipopt/scip.pxi":2551 + * ) + * PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip,disj_cons, (pycons).scip_cons)) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(pycons).scip_cons)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddCons(self._scip, disj_cons)) + * PyCons = Constraint.create(disj_cons) + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_v_pycons)->scip_cons))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_17 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + + /* "src/pyscipopt/scip.pxi":2545 + * + * # TODO add constraints to disjunction + * for i, cons in enumerate(conss): # <<<<<<<<<<<<<< + * pycons = self.createConsFromExpr(cons, name=name, initial = initial, + * enforce=enforce, check=check, + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2552 + * PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip,disj_cons, (pycons).scip_cons)) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(pycons).scip_cons)) + * PY_SCIP_CALL(SCIPaddCons(self._scip, disj_cons)) # <<<<<<<<<<<<<< + * PyCons = Constraint.create(disj_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &disj_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_17 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_disj_cons)); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_17}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2552, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2553 + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(pycons).scip_cons)) + * PY_SCIP_CALL(SCIPaddCons(self._scip, disj_cons)) + * PyCons = Constraint.create(disj_cons) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &disj_cons)) + * return PyCons + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_disj_cons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2553, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_PyCons = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2554 + * PY_SCIP_CALL(SCIPaddCons(self._scip, disj_cons)) + * PyCons = Constraint.create(disj_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &disj_cons)) # <<<<<<<<<<<<<< + * return PyCons + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2554, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_17 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&__pyx_v_disj_cons))); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 2554, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_17}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2554, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2555 + * PyCons = Constraint.create(disj_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &disj_cons)) + * return PyCons # <<<<<<<<<<<<<< + * + * def addConsElemDisjunction(self, Constraint disj_cons, Constraint cons): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_PyCons); + __pyx_r = __pyx_v_PyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2506 + * return constraints + * + * def addConsDisjunction(self, conss, name = '', initial = True, # <<<<<<<<<<<<<< + * relaxcons = None, enforce=True, check =True, + * local=False, modifiable = False, dynamic = False): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsDisjunction", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ensure_iterable); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_cons); + __Pyx_XDECREF(__pyx_v_pycons); + __Pyx_XDECREF(__pyx_v_PyCons); + __Pyx_XDECREF(__pyx_v_conss); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2557 + * return PyCons + * + * def addConsElemDisjunction(self, Constraint disj_cons, Constraint cons): # <<<<<<<<<<<<<< + * """Appends a constraint to a disjunction. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_271addConsElemDisjunction(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_270addConsElemDisjunction, "Model.addConsElemDisjunction(self, Constraint disj_cons, Constraint cons)\nAppends a constraint to a disjunction.\n\n :param Constraint disj_cons: the disjunction constraint to append to.\n :param Constraint cons: the Constraint to append\n :return The disjunction constraint with added @ref scip#Constraint object.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_271addConsElemDisjunction = {"addConsElemDisjunction", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_271addConsElemDisjunction, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_270addConsElemDisjunction}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_271addConsElemDisjunction(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_disj_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsElemDisjunction (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_disj_cons,&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_disj_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2557, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2557, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addConsElemDisjunction", 1, 2, 2, 1); __PYX_ERR(0, 2557, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsElemDisjunction") < 0)) __PYX_ERR(0, 2557, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_disj_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsElemDisjunction", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 2557, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsElemDisjunction", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_disj_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "disj_cons", 0))) __PYX_ERR(0, 2557, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 2557, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_270addConsElemDisjunction(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_disj_cons, __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_270addConsElemDisjunction(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_disj_cons, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsElemDisjunction", 1); + + /* "src/pyscipopt/scip.pxi":2564 + * :return The disjunction constraint with added @ref scip#Constraint object. + * """ + * PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip, (disj_cons).scip_cons, (cons).scip_cons)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(cons).scip_cons)) + * return disj_cons + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2564, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddConsElemDisjunction(__pyx_v_self->_scip, __pyx_v_disj_cons->scip_cons, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2564, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2564, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2565 + * """ + * PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip, (disj_cons).scip_cons, (cons).scip_cons)) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(cons).scip_cons)) # <<<<<<<<<<<<<< + * return disj_cons + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2566 + * PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip, (disj_cons).scip_cons, (cons).scip_cons)) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(cons).scip_cons)) + * return disj_cons # <<<<<<<<<<<<<< + * + * def getConsNVars(self, Constraint constraint): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_disj_cons); + __pyx_r = ((PyObject *)__pyx_v_disj_cons); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2557 + * return PyCons + * + * def addConsElemDisjunction(self, Constraint disj_cons, Constraint cons): # <<<<<<<<<<<<<< + * """Appends a constraint to a disjunction. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsElemDisjunction", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2568 + * return disj_cons + * + * def getConsNVars(self, Constraint constraint): # <<<<<<<<<<<<<< + * """ + * Gets number of variables in a constraint. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_273getConsNVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_272getConsNVars, "Model.getConsNVars(self, Constraint constraint)\n\n Gets number of variables in a constraint.\n\n :param constraint: Constraint to get the number of variables from.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_273getConsNVars = {"getConsNVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_273getConsNVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_272getConsNVars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_273getConsNVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getConsNVars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2568, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getConsNVars") < 0)) __PYX_ERR(0, 2568, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getConsNVars", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2568, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getConsNVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_constraint), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "constraint", 0))) __PYX_ERR(0, 2568, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_272getConsNVars(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_272getConsNVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint) { + int __pyx_v_nvars; + SCIP_Bool __pyx_v_success; + SCIP_CONSHDLR *__pyx_v_conshdlr; + char const *__pyx_v_conshdrlname; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getConsNVars", 1); + + /* "src/pyscipopt/scip.pxi":2577 + * cdef SCIP_Bool success + * + * PY_SCIP_CALL(SCIPgetConsNVars(self._scip, constraint.scip_cons, &nvars, &success)) # <<<<<<<<<<<<<< + * + * if not success: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetConsNVars(__pyx_v_self->_scip, __pyx_v_constraint->scip_cons, (&__pyx_v_nvars), (&__pyx_v_success))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2579 + * PY_SCIP_CALL(SCIPgetConsNVars(self._scip, constraint.scip_cons, &nvars, &success)) + * + * if not success: # <<<<<<<<<<<<<< + * conshdlr = SCIPconsGetHdlr(constraint.scip_cons) + * conshdrlname = SCIPconshdlrGetName(conshdlr) + */ + __pyx_t_6 = (!(__pyx_v_success != 0)); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":2580 + * + * if not success: + * conshdlr = SCIPconsGetHdlr(constraint.scip_cons) # <<<<<<<<<<<<<< + * conshdrlname = SCIPconshdlrGetName(conshdlr) + * raise TypeError("The constraint handler %s does not have this functionality." % conshdrlname) + */ + __pyx_v_conshdlr = SCIPconsGetHdlr(__pyx_v_constraint->scip_cons); + + /* "src/pyscipopt/scip.pxi":2581 + * if not success: + * conshdlr = SCIPconsGetHdlr(constraint.scip_cons) + * conshdrlname = SCIPconshdlrGetName(conshdlr) # <<<<<<<<<<<<<< + * raise TypeError("The constraint handler %s does not have this functionality." % conshdrlname) + * + */ + __pyx_v_conshdrlname = SCIPconshdlrGetName(__pyx_v_conshdlr); + + /* "src/pyscipopt/scip.pxi":2582 + * conshdlr = SCIPconsGetHdlr(constraint.scip_cons) + * conshdrlname = SCIPconshdlrGetName(conshdlr) + * raise TypeError("The constraint handler %s does not have this functionality." % conshdrlname) # <<<<<<<<<<<<<< + * + * return nvars + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_conshdrlname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyUnicode_Format(__pyx_kp_u_The_constraint_handler_s_does_no, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 2582, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2579 + * PY_SCIP_CALL(SCIPgetConsNVars(self._scip, constraint.scip_cons, &nvars, &success)) + * + * if not success: # <<<<<<<<<<<<<< + * conshdlr = SCIPconsGetHdlr(constraint.scip_cons) + * conshdrlname = SCIPconshdlrGetName(conshdlr) + */ + } + + /* "src/pyscipopt/scip.pxi":2584 + * raise TypeError("The constraint handler %s does not have this functionality." % conshdrlname) + * + * return nvars # <<<<<<<<<<<<<< + * + * def getConsVars(self, Constraint constraint): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_nvars); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2568 + * return disj_cons + * + * def getConsNVars(self, Constraint constraint): # <<<<<<<<<<<<<< + * """ + * Gets number of variables in a constraint. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getConsNVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2586 + * return nvars + * + * def getConsVars(self, Constraint constraint): # <<<<<<<<<<<<<< + * """ + * Gets variables in a constraint. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_275getConsVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_274getConsVars, "Model.getConsVars(self, Constraint constraint)\n\n Gets variables in a constraint.\n\n :param constraint: Constraint to get the variables from.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_275getConsVars = {"getConsVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_275getConsVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_274getConsVars}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_275getConsVars(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getConsVars (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2586, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getConsVars") < 0)) __PYX_ERR(0, 2586, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getConsVars", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2586, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getConsVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_constraint), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "constraint", 0))) __PYX_ERR(0, 2586, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_274getConsVars(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_274getConsVars(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint) { + SCIP_Bool __pyx_v_success; + int __pyx_v__nvars; + SCIP_VAR **__pyx_v__vars; + PyObject *__pyx_v_vars = NULL; + int __pyx_v_i; + size_t __pyx_v_ptr; + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getConsVars", 1); + + /* "src/pyscipopt/scip.pxi":2595 + * cdef int _nvars + * + * SCIPgetConsNVars(self._scip, constraint.scip_cons, &_nvars, &success) # <<<<<<<<<<<<<< + * + * cdef SCIP_VAR** _vars = malloc(_nvars * sizeof(SCIP_VAR*)) + */ + (void)(SCIPgetConsNVars(__pyx_v_self->_scip, __pyx_v_constraint->scip_cons, (&__pyx_v__nvars), (&__pyx_v_success))); + + /* "src/pyscipopt/scip.pxi":2597 + * SCIPgetConsNVars(self._scip, constraint.scip_cons, &_nvars, &success) + * + * cdef SCIP_VAR** _vars = malloc(_nvars * sizeof(SCIP_VAR*)) # <<<<<<<<<<<<<< + * SCIPgetConsVars(self._scip, constraint.scip_cons, _vars, _nvars*sizeof(SCIP_VAR*), &success) + * + */ + __pyx_v__vars = ((SCIP_VAR **)malloc((__pyx_v__nvars * (sizeof(SCIP_VAR *))))); + + /* "src/pyscipopt/scip.pxi":2598 + * + * cdef SCIP_VAR** _vars = malloc(_nvars * sizeof(SCIP_VAR*)) + * SCIPgetConsVars(self._scip, constraint.scip_cons, _vars, _nvars*sizeof(SCIP_VAR*), &success) # <<<<<<<<<<<<<< + * + * vars = [] + */ + (void)(SCIPgetConsVars(__pyx_v_self->_scip, __pyx_v_constraint->scip_cons, __pyx_v__vars, (__pyx_v__nvars * (sizeof(SCIP_VAR *))), (&__pyx_v_success))); + + /* "src/pyscipopt/scip.pxi":2600 + * SCIPgetConsVars(self._scip, constraint.scip_cons, _vars, _nvars*sizeof(SCIP_VAR*), &success) + * + * vars = [] # <<<<<<<<<<<<<< + * for i in range(_nvars): + * ptr = (_vars[i]) + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_vars = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2601 + * + * vars = [] + * for i in range(_nvars): # <<<<<<<<<<<<<< + * ptr = (_vars[i]) + * # check whether the corresponding variable exists already + */ + __pyx_t_2 = __pyx_v__nvars; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/scip.pxi":2602 + * vars = [] + * for i in range(_nvars): + * ptr = (_vars[i]) # <<<<<<<<<<<<<< + * # check whether the corresponding variable exists already + * if ptr in self._modelvars: + */ + __pyx_v_ptr = ((size_t)(__pyx_v__vars[__pyx_v_i])); + + /* "src/pyscipopt/scip.pxi":2604 + * ptr = (_vars[i]) + * # check whether the corresponding variable exists already + * if ptr in self._modelvars: # <<<<<<<<<<<<<< + * vars.append(self._modelvars[ptr]) + * else: + */ + __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_ptr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_v_self->_modelvars, Py_EQ)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 2604, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":2605 + * # check whether the corresponding variable exists already + * if ptr in self._modelvars: + * vars.append(self._modelvars[ptr]) # <<<<<<<<<<<<<< + * else: + * # create a new variable + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_self->_modelvars, __pyx_v_ptr, size_t, 0, __Pyx_PyInt_FromSize_t, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_vars, __pyx_t_1); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 2605, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2604 + * ptr = (_vars[i]) + * # check whether the corresponding variable exists already + * if ptr in self._modelvars: # <<<<<<<<<<<<<< + * vars.append(self._modelvars[ptr]) + * else: + */ + goto __pyx_L5; + } + + /* "src/pyscipopt/scip.pxi":2608 + * else: + * # create a new variable + * var = Variable.create(_vars[i]) # <<<<<<<<<<<<<< + * assert var.ptr() == ptr + * self._modelvars[ptr] = var + */ + /*else*/ { + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v__vars[__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2609 + * # create a new variable + * var = Variable.create(_vars[i]) + * assert var.ptr() == ptr # <<<<<<<<<<<<<< + * self._modelvars[ptr] = var + * vars.append(var) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_ptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_9, 0+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __pyx_t_7 = __Pyx_PyInt_FromSize_t(__pyx_v_ptr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2609, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyObject_RichCompare(__pyx_t_1, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2609, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 2609, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 2609, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2609, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2610 + * var = Variable.create(_vars[i]) + * assert var.ptr() == ptr + * self._modelvars[ptr] = var # <<<<<<<<<<<<<< + * vars.append(var) + * return vars + */ + if (unlikely((__Pyx_SetItemInt(__pyx_v_self->_modelvars, __pyx_v_ptr, __pyx_v_var, size_t, 0, __Pyx_PyInt_FromSize_t, 0, 0, 1) < 0))) __PYX_ERR(0, 2610, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2611 + * assert var.ptr() == ptr + * self._modelvars[ptr] = var + * vars.append(var) # <<<<<<<<<<<<<< + * return vars + * + */ + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_vars, __pyx_v_var); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 2611, __pyx_L1_error) + } + __pyx_L5:; + } + + /* "src/pyscipopt/scip.pxi":2612 + * self._modelvars[ptr] = var + * vars.append(var) + * return vars # <<<<<<<<<<<<<< + * + * def printCons(self, Constraint constraint): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_vars); + __pyx_r = __pyx_v_vars; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2586 + * return nvars + * + * def getConsVars(self, Constraint constraint): # <<<<<<<<<<<<<< + * """ + * Gets variables in a constraint. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.getConsVars", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_vars); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2614 + * return vars + * + * def printCons(self, Constraint constraint): # <<<<<<<<<<<<<< + * return PY_SCIP_CALL(SCIPprintCons(self._scip, constraint.scip_cons, NULL)) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_277printCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_276printCons, "Model.printCons(self, Constraint constraint)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_277printCons = {"printCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_277printCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_276printCons}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_277printCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("printCons (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_constraint,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_constraint)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2614, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "printCons") < 0)) __PYX_ERR(0, 2614, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_constraint = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("printCons", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2614, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.printCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_constraint), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "constraint", 0))) __PYX_ERR(0, 2614, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_276printCons(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_constraint); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_276printCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("printCons", 1); + + /* "src/pyscipopt/scip.pxi":2615 + * + * def printCons(self, Constraint constraint): + * return PY_SCIP_CALL(SCIPprintCons(self._scip, constraint.scip_cons, NULL)) # <<<<<<<<<<<<<< + * + * # TODO Find a better way to retrieve a scip expression from a python expression. Consider making GenExpr include Expr, to avoid using Union. See PR #760. + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintCons(__pyx_v_self->_scip, __pyx_v_constraint->scip_cons, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2614 + * return vars + * + * def printCons(self, Constraint constraint): # <<<<<<<<<<<<<< + * return PY_SCIP_CALL(SCIPprintCons(self._scip, constraint.scip_cons, NULL)) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.printCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2619 + * # TODO Find a better way to retrieve a scip expression from a python expression. Consider making GenExpr include Expr, to avoid using Union. See PR #760. + * from typing import Union + * def addExprNonlinear(self, Constraint cons, expr: Union[Expr,GenExpr], float coef): # <<<<<<<<<<<<<< + * """ + * Add coef*expr to nonlinear constraint. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_279addExprNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_278addExprNonlinear, "Model.addExprNonlinear(self, Constraint cons, expr: Union[Expr, GenExpr], float coef)\n\n Add coef*expr to nonlinear constraint.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_279addExprNonlinear = {"addExprNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_279addExprNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_278addExprNonlinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_279addExprNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + PyObject *__pyx_v_expr = 0; + float __pyx_v_coef; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addExprNonlinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_expr,&__pyx_n_s_coef,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2619, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2619, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addExprNonlinear", 1, 3, 3, 1); __PYX_ERR(0, 2619, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_coef)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2619, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addExprNonlinear", 1, 3, 3, 2); __PYX_ERR(0, 2619, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addExprNonlinear") < 0)) __PYX_ERR(0, 2619, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_expr = values[1]; + __pyx_v_coef = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_coef == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2619, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addExprNonlinear", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2619, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addExprNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 2619, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_278addExprNonlinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_expr, __pyx_v_coef); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_278addExprNonlinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_expr, float __pyx_v_coef) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_temp_cons = 0; + SCIP_EXPR *__pyx_v_scip_expr; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addExprNonlinear", 1); + + /* "src/pyscipopt/scip.pxi":2623 + * Add coef*expr to nonlinear constraint. + * """ + * assert self.getStage() == 1, "addExprNonlinear cannot be called in stage %i." % self.getStage() # <<<<<<<<<<<<<< + * assert cons.isNonlinear(), "addExprNonlinear can only be called with nonlinear constraints." + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = (__Pyx_PyInt_BoolEqObjC(__pyx_t_1, __pyx_int_1, 1, 0)); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 2623, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_addExprNonlinear_cannot_be_calle, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_2, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2623, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2623, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2624 + * """ + * assert self.getStage() == 1, "addExprNonlinear cannot be called in stage %i." % self.getStage() + * assert cons.isNonlinear(), "addExprNonlinear can only be called with nonlinear constraints." # <<<<<<<<<<<<<< + * + * cdef Constraint temp_cons + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cons), __pyx_n_s_isNonlinear); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 2624, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_addExprNonlinear_can_only_be_cal, 0, 0); + __PYX_ERR(0, 2624, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2624, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2629 + * cdef SCIP_EXPR* scip_expr + * + * temp_cons = self.addCons(expr <= 0) # <<<<<<<<<<<<<< + * scip_expr = SCIPgetExprNonlinear(temp_cons.scip_cons) + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_addCons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_expr, __pyx_int_0, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2629, __pyx_L1_error) + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pyscipopt_4scip_Constraint))))) __PYX_ERR(0, 2629, __pyx_L1_error) + __pyx_v_temp_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2630 + * + * temp_cons = self.addCons(expr <= 0) + * scip_expr = SCIPgetExprNonlinear(temp_cons.scip_cons) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddExprNonlinear(self._scip, cons.scip_cons, scip_expr, coef)) + */ + __pyx_v_scip_expr = SCIPgetExprNonlinear(__pyx_v_temp_cons->scip_cons); + + /* "src/pyscipopt/scip.pxi":2632 + * scip_expr = SCIPgetExprNonlinear(temp_cons.scip_cons) + * + * PY_SCIP_CALL(SCIPaddExprNonlinear(self._scip, cons.scip_cons, scip_expr, coef)) # <<<<<<<<<<<<<< + * self.delCons(temp_cons) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2632, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddExprNonlinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_scip_expr, __pyx_v_coef)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2632, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2632, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2633 + * + * PY_SCIP_CALL(SCIPaddExprNonlinear(self._scip, cons.scip_cons, scip_expr, coef)) + * self.delCons(temp_cons) # <<<<<<<<<<<<<< + * + * def addConsCoeff(self, Constraint cons, Variable var, coeff): + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_delCons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2633, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_temp_cons)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2633, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2619 + * # TODO Find a better way to retrieve a scip expression from a python expression. Consider making GenExpr include Expr, to avoid using Union. See PR #760. + * from typing import Union + * def addExprNonlinear(self, Constraint cons, expr: Union[Expr,GenExpr], float coef): # <<<<<<<<<<<<<< + * """ + * Add coef*expr to nonlinear constraint. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.addExprNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_temp_cons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2635 + * self.delCons(temp_cons) + * + * def addConsCoeff(self, Constraint cons, Variable var, coeff): # <<<<<<<<<<<<<< + * """Add coefficient to the linear constraint (if non-zero). + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_281addConsCoeff(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_280addConsCoeff, "Model.addConsCoeff(self, Constraint cons, Variable var, coeff)\nAdd coefficient to the linear constraint (if non-zero).\n\n :param Constraint cons: constraint to be changed\n :param Variable var: variable to be added\n :param coeff: coefficient of new variable\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_281addConsCoeff = {"addConsCoeff", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_281addConsCoeff, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_280addConsCoeff}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_281addConsCoeff(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_coeff = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsCoeff (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_var,&__pyx_n_s_coeff,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2635, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2635, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addConsCoeff", 1, 3, 3, 1); __PYX_ERR(0, 2635, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_coeff)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2635, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addConsCoeff", 1, 3, 3, 2); __PYX_ERR(0, 2635, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsCoeff") < 0)) __PYX_ERR(0, 2635, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_coeff = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsCoeff", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2635, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsCoeff", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 2635, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 2635, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_280addConsCoeff(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_var, __pyx_v_coeff); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_280addConsCoeff(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_coeff) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsCoeff", 1); + + /* "src/pyscipopt/scip.pxi":2643 + * + * """ + * PY_SCIP_CALL(SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, coeff)) # <<<<<<<<<<<<<< + * + * def addConsNode(self, Node node, Constraint cons, Node validnode=None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_coeff); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2643, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCoefLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2635 + * self.delCons(temp_cons) + * + * def addConsCoeff(self, Constraint cons, Variable var, coeff): # <<<<<<<<<<<<<< + * """Add coefficient to the linear constraint (if non-zero). + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsCoeff", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2645 + * PY_SCIP_CALL(SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, coeff)) + * + * def addConsNode(self, Node node, Constraint cons, Node validnode=None): # <<<<<<<<<<<<<< + * """Add a constraint to the given node + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_283addConsNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_282addConsNode, "Model.addConsNode(self, Node node, Constraint cons, Node validnode=None)\nAdd a constraint to the given node\n\n :param Node node: node to add the constraint to\n :param Constraint cons: constraint to add\n :param Node validnode: more global node where cons is also valid\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_283addConsNode = {"addConsNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_283addConsNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_282addConsNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_283addConsNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node = 0; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_validnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_node,&__pyx_n_s_cons,&__pyx_n_s_validnode,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Node *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_node)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2645, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2645, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addConsNode", 0, 2, 3, 1); __PYX_ERR(0, 2645, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_validnode); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2645, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsNode") < 0)) __PYX_ERR(0, 2645, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_node = ((struct __pyx_obj_9pyscipopt_4scip_Node *)values[0]); + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[1]); + __pyx_v_validnode = ((struct __pyx_obj_9pyscipopt_4scip_Node *)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsNode", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 2645, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_node), __pyx_ptype_9pyscipopt_4scip_Node, 1, "node", 0))) __PYX_ERR(0, 2645, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 2645, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_validnode), __pyx_ptype_9pyscipopt_4scip_Node, 1, "validnode", 0))) __PYX_ERR(0, 2645, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_282addConsNode(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_node, __pyx_v_cons, __pyx_v_validnode); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_282addConsNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_node, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_validnode) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsNode", 1); + + /* "src/pyscipopt/scip.pxi":2653 + * + * """ + * if isinstance(validnode, Node): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, validnode.scip_node)) + * else: + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_validnode), __pyx_ptype_9pyscipopt_4scip_Node); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":2654 + * """ + * if isinstance(validnode, Node): + * PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, validnode.scip_node)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, NULL)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddConsNode(__pyx_v_self->_scip, __pyx_v_node->scip_node, __pyx_v_cons->scip_cons, __pyx_v_validnode->scip_node)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2653 + * + * """ + * if isinstance(validnode, Node): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, validnode.scip_node)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":2656 + * PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, validnode.scip_node)) + * else: + * PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, NULL)) # <<<<<<<<<<<<<< + * Py_INCREF(cons) + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddConsNode(__pyx_v_self->_scip, __pyx_v_node->scip_node, __pyx_v_cons->scip_cons, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":2657 + * else: + * PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, NULL)) + * Py_INCREF(cons) # <<<<<<<<<<<<<< + * + * def addConsLocal(self, Constraint cons, Node validnode=None): + */ + Py_INCREF(((PyObject *)__pyx_v_cons)); + + /* "src/pyscipopt/scip.pxi":2645 + * PY_SCIP_CALL(SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, coeff)) + * + * def addConsNode(self, Node node, Constraint cons, Node validnode=None): # <<<<<<<<<<<<<< + * """Add a constraint to the given node + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2659 + * Py_INCREF(cons) + * + * def addConsLocal(self, Constraint cons, Node validnode=None): # <<<<<<<<<<<<<< + * """Add a constraint to the current node + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_285addConsLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_284addConsLocal, "Model.addConsLocal(self, Constraint cons, Node validnode=None)\nAdd a constraint to the current node\n\n :param Constraint cons: constraint to add\n :param Node validnode: more global node where cons is also valid\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_285addConsLocal = {"addConsLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_285addConsLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_284addConsLocal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_285addConsLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_validnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsLocal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_validnode,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Node *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2659, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_validnode); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2659, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsLocal") < 0)) __PYX_ERR(0, 2659, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_validnode = ((struct __pyx_obj_9pyscipopt_4scip_Node *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsLocal", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 2659, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsLocal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 2659, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_validnode), __pyx_ptype_9pyscipopt_4scip_Node, 1, "validnode", 0))) __PYX_ERR(0, 2659, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_284addConsLocal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_validnode); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_284addConsLocal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Node *__pyx_v_validnode) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsLocal", 1); + + /* "src/pyscipopt/scip.pxi":2666 + * + * """ + * if isinstance(validnode, Node): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, validnode.scip_node)) + * else: + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_validnode), __pyx_ptype_9pyscipopt_4scip_Node); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":2667 + * """ + * if isinstance(validnode, Node): + * PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, validnode.scip_node)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, NULL)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddConsLocal(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_validnode->scip_node)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2667, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2666 + * + * """ + * if isinstance(validnode, Node): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, validnode.scip_node)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":2669 + * PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, validnode.scip_node)) + * else: + * PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, NULL)) # <<<<<<<<<<<<<< + * Py_INCREF(cons) + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddConsLocal(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":2670 + * else: + * PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, NULL)) + * Py_INCREF(cons) # <<<<<<<<<<<<<< + * + * def addConsSOS1(self, vars, weights=None, name="SOS1cons", + */ + Py_INCREF(((PyObject *)__pyx_v_cons)); + + /* "src/pyscipopt/scip.pxi":2659 + * Py_INCREF(cons) + * + * def addConsLocal(self, Constraint cons, Node validnode=None): # <<<<<<<<<<<<<< + * """Add a constraint to the current node + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsLocal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2672 + * Py_INCREF(cons) + * + * def addConsSOS1(self, vars, weights=None, name="SOS1cons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_287addConsSOS1(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_286addConsSOS1, "Model.addConsSOS1(self, vars, weights=None, name=u'SOS1cons', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, dynamic=False, removable=False, stickingatnode=False)\nAdd an SOS1 constraint.\n\n :param vars: list of variables to be included\n :param weights: list of weights (Default value = None)\n :param name: name of the constraint (Default value = \"SOS1cons\")\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: should the constraint be propagated during node processing? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_287addConsSOS1 = {"addConsSOS1", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_287addConsSOS1, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_286addConsSOS1}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_287addConsSOS1(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_vars = 0; + PyObject *__pyx_v_weights = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsSOS1 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_vars,&__pyx_n_s_weights,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_SOS1cons)); + + /* "src/pyscipopt/scip.pxi":2673 + * + * def addConsSOS1(self, vars, weights=None, name="SOS1cons", + * initial=True, separate=True, enforce=True, check=True, # <<<<<<<<<<<<<< + * propagate=True, local=False, dynamic=False, + * removable=False, stickingatnode=False): + */ + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2674 + * def addConsSOS1(self, vars, weights=None, name="SOS1cons", + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, # <<<<<<<<<<<<<< + * removable=False, stickingatnode=False): + * """Add an SOS1 constraint. + */ + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2675 + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + * removable=False, stickingatnode=False): # <<<<<<<<<<<<<< + * """Add an SOS1 constraint. + * + */ + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_weights); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2672, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsSOS1") < 0)) __PYX_ERR(0, 2672, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_vars = values[0]; + __pyx_v_weights = values[1]; + __pyx_v_name = values[2]; + __pyx_v_initial = values[3]; + __pyx_v_separate = values[4]; + __pyx_v_enforce = values[5]; + __pyx_v_check = values[6]; + __pyx_v_propagate = values[7]; + __pyx_v_local = values[8]; + __pyx_v_dynamic = values[9]; + __pyx_v_removable = values[10]; + __pyx_v_stickingatnode = values[11]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsSOS1", 0, 1, 12, __pyx_nargs); __PYX_ERR(0, 2672, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsSOS1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_286addConsSOS1(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_vars, __pyx_v_weights, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2672 + * Py_INCREF(cons) + * + * def addConsSOS1(self, vars, weights=None, name="SOS1cons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_286addConsSOS1(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_weights, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + SCIP_CONS *__pyx_v_scip_cons; + PyObject *__pyx_v_v = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + Py_ssize_t __pyx_v_nvars; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + char const *__pyx_t_7; + SCIP_Bool __pyx_t_8; + SCIP_Bool __pyx_t_9; + SCIP_Bool __pyx_t_10; + SCIP_Bool __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + int __pyx_t_17; + Py_ssize_t __pyx_t_18; + PyObject *(*__pyx_t_19)(PyObject *); + Py_ssize_t __pyx_t_20; + Py_ssize_t __pyx_t_21; + SCIP_Real __pyx_t_22; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsSOS1", 1); + + /* "src/pyscipopt/scip.pxi":2695 + * cdef int _nvars + * + * PY_SCIP_CALL(SCIPcreateConsSOS1(self._scip, &scip_cons, str_conversion(name), 0, NULL, NULL, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_name}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_t_3); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 2695, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2696 + * + * PY_SCIP_CALL(SCIPcreateConsSOS1(self._scip, &scip_cons, str_conversion(name), 0, NULL, NULL, + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) # <<<<<<<<<<<<<< + * + * if weights is None: + */ + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_separate); if (unlikely((__pyx_t_9 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_propagate); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_stickingatnode); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2696, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2695 + * cdef int _nvars + * + * PY_SCIP_CALL(SCIPcreateConsSOS1(self._scip, &scip_cons, str_conversion(name), 0, NULL, NULL, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + */ + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsSOS1(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_7, 0, NULL, NULL, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2698 + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + * if weights is None: # <<<<<<<<<<<<<< + * for v in vars: + * var = v + */ + __pyx_t_17 = (__pyx_v_weights == Py_None); + if (__pyx_t_17) { + + /* "src/pyscipopt/scip.pxi":2699 + * + * if weights is None: + * for v in vars: # <<<<<<<<<<<<<< + * var = v + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, scip_cons, var.scip_var)) + */ + if (likely(PyList_CheckExact(__pyx_v_vars)) || PyTuple_CheckExact(__pyx_v_vars)) { + __pyx_t_1 = __pyx_v_vars; __Pyx_INCREF(__pyx_t_1); + __pyx_t_18 = 0; + __pyx_t_19 = NULL; + } else { + __pyx_t_18 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_vars); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_19 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 2699, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_19)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2699, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_18); __Pyx_INCREF(__pyx_t_2); __pyx_t_18++; if (unlikely((0 < 0))) __PYX_ERR(0, 2699, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_18); __pyx_t_18++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2699, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_18); __Pyx_INCREF(__pyx_t_2); __pyx_t_18++; if (unlikely((0 < 0))) __PYX_ERR(0, 2699, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_18); __pyx_t_18++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_19(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2699, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2700 + * if weights is None: + * for v in vars: + * var = v # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, scip_cons, var.scip_var)) + * else: + */ + __pyx_t_2 = __pyx_v_v; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2701 + * for v in vars: + * var = v + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, scip_cons, var.scip_var)) # <<<<<<<<<<<<<< + * else: + * nvars = len(vars) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPappendVarSOS1(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2701, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2699 + * + * if weights is None: + * for v in vars: # <<<<<<<<<<<<<< + * var = v + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, scip_cons, var.scip_var)) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2698 + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + * if weights is None: # <<<<<<<<<<<<<< + * for v in vars: + * var = v + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":2703 + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, scip_cons, var.scip_var)) + * else: + * nvars = len(vars) # <<<<<<<<<<<<<< + * for i in range(nvars): + * var = vars[i] + */ + /*else*/ { + __pyx_t_18 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2703, __pyx_L1_error) + __pyx_v_nvars = __pyx_t_18; + + /* "src/pyscipopt/scip.pxi":2704 + * else: + * nvars = len(vars) + * for i in range(nvars): # <<<<<<<<<<<<<< + * var = vars[i] + * PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, scip_cons, var.scip_var, weights[i])) + */ + __pyx_t_18 = __pyx_v_nvars; + __pyx_t_20 = __pyx_t_18; + for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { + __pyx_v_i = __pyx_t_21; + + /* "src/pyscipopt/scip.pxi":2705 + * nvars = len(vars) + * for i in range(nvars): + * var = vars[i] # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, scip_cons, var.scip_var, weights[i])) + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_vars, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2706 + * for i in range(nvars): + * var = vars[i] + * PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, scip_cons, var.scip_var, weights[i])) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_weights, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_22 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_22 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2706, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVarSOS1(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_var->scip_var, __pyx_t_22)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":2708 + * PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, scip_cons, var.scip_var, weights[i])) + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) # <<<<<<<<<<<<<< + * return Constraint.create(scip_cons) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_scip_cons)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2709 + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * return Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * + * def addConsSOS2(self, vars, weights=None, name="SOS2cons", + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2672 + * Py_INCREF(cons) + * + * def addConsSOS1(self, vars, weights=None, name="SOS1cons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsSOS1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2711 + * return Constraint.create(scip_cons) + * + * def addConsSOS2(self, vars, weights=None, name="SOS2cons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_289addConsSOS2(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_288addConsSOS2, "Model.addConsSOS2(self, vars, weights=None, name=u'SOS2cons', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, dynamic=False, removable=False, stickingatnode=False)\nAdd an SOS2 constraint.\n\n :param vars: list of variables to be included\n :param weights: list of weights (Default value = None)\n :param name: name of the constraint (Default value = \"SOS2cons\")\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: is the constraint only valid locally? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_289addConsSOS2 = {"addConsSOS2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_289addConsSOS2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_288addConsSOS2}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_289addConsSOS2(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_vars = 0; + PyObject *__pyx_v_weights = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsSOS2 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_vars,&__pyx_n_s_weights,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_SOS2cons)); + + /* "src/pyscipopt/scip.pxi":2712 + * + * def addConsSOS2(self, vars, weights=None, name="SOS2cons", + * initial=True, separate=True, enforce=True, check=True, # <<<<<<<<<<<<<< + * propagate=True, local=False, dynamic=False, + * removable=False, stickingatnode=False): + */ + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2713 + * def addConsSOS2(self, vars, weights=None, name="SOS2cons", + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, # <<<<<<<<<<<<<< + * removable=False, stickingatnode=False): + * """Add an SOS2 constraint. + */ + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2714 + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + * removable=False, stickingatnode=False): # <<<<<<<<<<<<<< + * """Add an SOS2 constraint. + * + */ + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_weights); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2711, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsSOS2") < 0)) __PYX_ERR(0, 2711, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_vars = values[0]; + __pyx_v_weights = values[1]; + __pyx_v_name = values[2]; + __pyx_v_initial = values[3]; + __pyx_v_separate = values[4]; + __pyx_v_enforce = values[5]; + __pyx_v_check = values[6]; + __pyx_v_propagate = values[7]; + __pyx_v_local = values[8]; + __pyx_v_dynamic = values[9]; + __pyx_v_removable = values[10]; + __pyx_v_stickingatnode = values[11]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsSOS2", 0, 1, 12, __pyx_nargs); __PYX_ERR(0, 2711, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsSOS2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_288addConsSOS2(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_vars, __pyx_v_weights, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2711 + * return Constraint.create(scip_cons) + * + * def addConsSOS2(self, vars, weights=None, name="SOS2cons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_288addConsSOS2(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_weights, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + SCIP_CONS *__pyx_v_scip_cons; + PyObject *__pyx_v_v = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + Py_ssize_t __pyx_v_nvars; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + char const *__pyx_t_7; + SCIP_Bool __pyx_t_8; + SCIP_Bool __pyx_t_9; + SCIP_Bool __pyx_t_10; + SCIP_Bool __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + int __pyx_t_17; + Py_ssize_t __pyx_t_18; + PyObject *(*__pyx_t_19)(PyObject *); + Py_ssize_t __pyx_t_20; + Py_ssize_t __pyx_t_21; + SCIP_Real __pyx_t_22; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsSOS2", 1); + + /* "src/pyscipopt/scip.pxi":2734 + * cdef int _nvars + * + * PY_SCIP_CALL(SCIPcreateConsSOS2(self._scip, &scip_cons, str_conversion(name), 0, NULL, NULL, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_name}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_t_3); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 2734, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2735 + * + * PY_SCIP_CALL(SCIPcreateConsSOS2(self._scip, &scip_cons, str_conversion(name), 0, NULL, NULL, + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) # <<<<<<<<<<<<<< + * + * if weights is None: + */ + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_separate); if (unlikely((__pyx_t_9 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_propagate); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_stickingatnode); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2735, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2734 + * cdef int _nvars + * + * PY_SCIP_CALL(SCIPcreateConsSOS2(self._scip, &scip_cons, str_conversion(name), 0, NULL, NULL, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + */ + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsSOS2(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_7, 0, NULL, NULL, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2737 + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + * if weights is None: # <<<<<<<<<<<<<< + * for v in vars: + * var = v + */ + __pyx_t_17 = (__pyx_v_weights == Py_None); + if (__pyx_t_17) { + + /* "src/pyscipopt/scip.pxi":2738 + * + * if weights is None: + * for v in vars: # <<<<<<<<<<<<<< + * var = v + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, scip_cons, var.scip_var)) + */ + if (likely(PyList_CheckExact(__pyx_v_vars)) || PyTuple_CheckExact(__pyx_v_vars)) { + __pyx_t_1 = __pyx_v_vars; __Pyx_INCREF(__pyx_t_1); + __pyx_t_18 = 0; + __pyx_t_19 = NULL; + } else { + __pyx_t_18 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_vars); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_19 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 2738, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_19)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2738, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_18); __Pyx_INCREF(__pyx_t_2); __pyx_t_18++; if (unlikely((0 < 0))) __PYX_ERR(0, 2738, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_18); __pyx_t_18++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2738, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_18); __Pyx_INCREF(__pyx_t_2); __pyx_t_18++; if (unlikely((0 < 0))) __PYX_ERR(0, 2738, __pyx_L1_error) + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_18); __pyx_t_18++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + } + } else { + __pyx_t_2 = __pyx_t_19(__pyx_t_1); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2738, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2739 + * if weights is None: + * for v in vars: + * var = v # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, scip_cons, var.scip_var)) + * else: + */ + __pyx_t_2 = __pyx_v_v; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2740 + * for v in vars: + * var = v + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, scip_cons, var.scip_var)) # <<<<<<<<<<<<<< + * else: + * nvars = len(vars) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPappendVarSOS2(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2740, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2738 + * + * if weights is None: + * for v in vars: # <<<<<<<<<<<<<< + * var = v + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, scip_cons, var.scip_var)) + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2737 + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + * if weights is None: # <<<<<<<<<<<<<< + * for v in vars: + * var = v + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":2742 + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, scip_cons, var.scip_var)) + * else: + * nvars = len(vars) # <<<<<<<<<<<<<< + * for i in range(nvars): + * var = vars[i] + */ + /*else*/ { + __pyx_t_18 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2742, __pyx_L1_error) + __pyx_v_nvars = __pyx_t_18; + + /* "src/pyscipopt/scip.pxi":2743 + * else: + * nvars = len(vars) + * for i in range(nvars): # <<<<<<<<<<<<<< + * var = vars[i] + * PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, scip_cons, var.scip_var, weights[i])) + */ + __pyx_t_18 = __pyx_v_nvars; + __pyx_t_20 = __pyx_t_18; + for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { + __pyx_v_i = __pyx_t_21; + + /* "src/pyscipopt/scip.pxi":2744 + * nvars = len(vars) + * for i in range(nvars): + * var = vars[i] # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, scip_cons, var.scip_var, weights[i])) + * + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_vars, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2745 + * for i in range(nvars): + * var = vars[i] + * PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, scip_cons, var.scip_var, weights[i])) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_weights, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_22 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_22 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2745, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVarSOS2(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_var->scip_var, __pyx_t_22)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2745, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":2747 + * PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, scip_cons, var.scip_var, weights[i])) + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) # <<<<<<<<<<<<<< + * return Constraint.create(scip_cons) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_scip_cons)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2748 + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * return Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * + * def addConsAnd(self, vars, resvar, name="ANDcons", + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2711 + * return Constraint.create(scip_cons) + * + * def addConsSOS2(self, vars, weights=None, name="SOS2cons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsSOS2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2750 + * return Constraint.create(scip_cons) + * + * def addConsAnd(self, vars, resvar, name="ANDcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_291addConsAnd(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_290addConsAnd, "Model.addConsAnd(self, vars, resvar, name=u'ANDcons', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False)\nAdd an AND-constraint.\n :param vars: list of BINARY variables to be included (operators)\n :param resvar: BINARY variable (resultant)\n :param name: name of the constraint (Default value = \"ANDcons\")\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: should the constraint be propagated during node processing? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_291addConsAnd = {"addConsAnd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_291addConsAnd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_290addConsAnd}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_291addConsAnd(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_vars = 0; + PyObject *__pyx_v_resvar = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[13] = {0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsAnd (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_vars,&__pyx_n_s_resvar,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_ANDcons)); + + /* "src/pyscipopt/scip.pxi":2751 + * + * def addConsAnd(self, vars, resvar, name="ANDcons", + * initial=True, separate=True, enforce=True, check=True, # <<<<<<<<<<<<<< + * propagate=True, local=False, modifiable=False, dynamic=False, + * removable=False, stickingatnode=False): + */ + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2752 + * def addConsAnd(self, vars, resvar, name="ANDcons", + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, # <<<<<<<<<<<<<< + * removable=False, stickingatnode=False): + * """Add an AND-constraint. + */ + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2753 + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + * removable=False, stickingatnode=False): # <<<<<<<<<<<<<< + * """Add an AND-constraint. + * :param vars: list of BINARY variables to be included (operators) + */ + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[12] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_resvar)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addConsAnd", 0, 2, 13, 1); __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[12] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2750, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsAnd") < 0)) __PYX_ERR(0, 2750, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_vars = values[0]; + __pyx_v_resvar = values[1]; + __pyx_v_name = values[2]; + __pyx_v_initial = values[3]; + __pyx_v_separate = values[4]; + __pyx_v_enforce = values[5]; + __pyx_v_check = values[6]; + __pyx_v_propagate = values[7]; + __pyx_v_local = values[8]; + __pyx_v_modifiable = values[9]; + __pyx_v_dynamic = values[10]; + __pyx_v_removable = values[11]; + __pyx_v_stickingatnode = values[12]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsAnd", 0, 2, 13, __pyx_nargs); __PYX_ERR(0, 2750, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsAnd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_290addConsAnd(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_vars, __pyx_v_resvar, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_modifiable, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2750 + * return Constraint.create(scip_cons) + * + * def addConsAnd(self, vars, resvar, name="ANDcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_290addConsAnd(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_resvar, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + SCIP_CONS *__pyx_v_scip_cons; + Py_ssize_t __pyx_v_nvars; + SCIP_VAR **__pyx_v__vars; + PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_var = NULL; + SCIP_VAR *__pyx_v__resVar; + PyObject *__pyx_v_pyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + SCIP_VAR *__pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + char const *__pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + SCIP_Bool __pyx_t_17; + SCIP_Bool __pyx_t_18; + SCIP_Bool __pyx_t_19; + SCIP_Bool __pyx_t_20; + SCIP_Bool __pyx_t_21; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsAnd", 1); + + /* "src/pyscipopt/scip.pxi":2771 + * cdef SCIP_CONS* scip_cons + * + * nvars = len(vars) # <<<<<<<<<<<<<< + * + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + */ + __pyx_t_1 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2771, __pyx_L1_error) + __pyx_v_nvars = __pyx_t_1; + + /* "src/pyscipopt/scip.pxi":2773 + * nvars = len(vars) + * + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) # <<<<<<<<<<<<<< + * for idx, var in enumerate(vars): + * _vars[idx] = (var).scip_var + */ + __pyx_t_1 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2773, __pyx_L1_error) + __pyx_v__vars = ((SCIP_VAR **)malloc((__pyx_t_1 * (sizeof(SCIP_VAR *))))); + + /* "src/pyscipopt/scip.pxi":2774 + * + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): # <<<<<<<<<<<<<< + * _vars[idx] = (var).scip_var + * _resVar = (resvar).scip_var + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_2 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_vars)) || PyTuple_CheckExact(__pyx_v_vars)) { + __pyx_t_3 = __pyx_v_vars; __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_vars); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2774, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2774, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 2774, __pyx_L1_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2774, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 2774, __pyx_L1_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_3); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2774, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2775 + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): + * _vars[idx] = (var).scip_var # <<<<<<<<<<<<<< + * _resVar = (resvar).scip_var + * + */ + __pyx_t_6 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_var)->scip_var; + __pyx_t_7 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_7 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2775, __pyx_L1_error) + (__pyx_v__vars[__pyx_t_7]) = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":2774 + * + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): # <<<<<<<<<<<<<< + * _vars[idx] = (var).scip_var + * _resVar = (resvar).scip_var + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2776 + * for idx, var in enumerate(vars): + * _vars[idx] = (var).scip_var + * _resVar = (resvar).scip_var # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPcreateConsAnd(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars, + */ + __pyx_t_6 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_resvar)->scip_var; + __pyx_v__resVar = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":2778 + * _resVar = (resvar).scip_var + * + * PY_SCIP_CALL(SCIPcreateConsAnd(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_name}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_t_5); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) __PYX_ERR(0, 2778, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2779 + * + * PY_SCIP_CALL(SCIPcreateConsAnd(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars, + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + */ + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_separate); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_propagate); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_17 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_modifiable); if (unlikely((__pyx_t_18 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_19 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_v_stickingatnode); if (unlikely((__pyx_t_21 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2778 + * _resVar = (resvar).scip_var + * + * PY_SCIP_CALL(SCIPcreateConsAnd(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + */ + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsAnd(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_11, __pyx_v__resVar, __pyx_v_nvars, __pyx_v__vars, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2781 + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) # <<<<<<<<<<<<<< + * pyCons = Constraint.create(scip_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_scip_cons)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2782 + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_pyCons = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2783 + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pyCons = Constraint.create(scip_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) # <<<<<<<<<<<<<< + * + * free(_vars) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&__pyx_v_scip_cons))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2785 + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + * free(_vars) # <<<<<<<<<<<<<< + * + * return pyCons + */ + free(__pyx_v__vars); + + /* "src/pyscipopt/scip.pxi":2787 + * free(_vars) + * + * return pyCons # <<<<<<<<<<<<<< + * + * def addConsOr(self, vars, resvar, name="ORcons", + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyCons); + __pyx_r = __pyx_v_pyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2750 + * return Constraint.create(scip_cons) + * + * def addConsAnd(self, vars, resvar, name="ANDcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsAnd", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XDECREF(__pyx_v_pyCons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2789 + * return pyCons + * + * def addConsOr(self, vars, resvar, name="ORcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_293addConsOr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_292addConsOr, "Model.addConsOr(self, vars, resvar, name=u'ORcons', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False)\nAdd an OR-constraint.\n :param vars: list of BINARY variables to be included (operators)\n :param resvar: BINARY variable (resultant)\n :param name: name of the constraint (Default value = \"ORcons\")\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: should the constraint be propagated during node processing? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_293addConsOr = {"addConsOr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_293addConsOr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_292addConsOr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_293addConsOr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_vars = 0; + PyObject *__pyx_v_resvar = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[13] = {0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsOr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_vars,&__pyx_n_s_resvar,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_ORcons)); + + /* "src/pyscipopt/scip.pxi":2790 + * + * def addConsOr(self, vars, resvar, name="ORcons", + * initial=True, separate=True, enforce=True, check=True, # <<<<<<<<<<<<<< + * propagate=True, local=False, modifiable=False, dynamic=False, + * removable=False, stickingatnode=False): + */ + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2791 + * def addConsOr(self, vars, resvar, name="ORcons", + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, # <<<<<<<<<<<<<< + * removable=False, stickingatnode=False): + * """Add an OR-constraint. + */ + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2792 + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + * removable=False, stickingatnode=False): # <<<<<<<<<<<<<< + * """Add an OR-constraint. + * :param vars: list of BINARY variables to be included (operators) + */ + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[12] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_resvar)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addConsOr", 0, 2, 13, 1); __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[12] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2789, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsOr") < 0)) __PYX_ERR(0, 2789, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_vars = values[0]; + __pyx_v_resvar = values[1]; + __pyx_v_name = values[2]; + __pyx_v_initial = values[3]; + __pyx_v_separate = values[4]; + __pyx_v_enforce = values[5]; + __pyx_v_check = values[6]; + __pyx_v_propagate = values[7]; + __pyx_v_local = values[8]; + __pyx_v_modifiable = values[9]; + __pyx_v_dynamic = values[10]; + __pyx_v_removable = values[11]; + __pyx_v_stickingatnode = values[12]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsOr", 0, 2, 13, __pyx_nargs); __PYX_ERR(0, 2789, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsOr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_292addConsOr(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_vars, __pyx_v_resvar, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_modifiable, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2789 + * return pyCons + * + * def addConsOr(self, vars, resvar, name="ORcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_292addConsOr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_resvar, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + SCIP_CONS *__pyx_v_scip_cons; + Py_ssize_t __pyx_v_nvars; + SCIP_VAR **__pyx_v__vars; + PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_var = NULL; + SCIP_VAR *__pyx_v__resVar; + PyObject *__pyx_v_pyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + SCIP_VAR *__pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_t_10; + char const *__pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + SCIP_Bool __pyx_t_17; + SCIP_Bool __pyx_t_18; + SCIP_Bool __pyx_t_19; + SCIP_Bool __pyx_t_20; + SCIP_Bool __pyx_t_21; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsOr", 1); + + /* "src/pyscipopt/scip.pxi":2810 + * cdef SCIP_CONS* scip_cons + * + * nvars = len(vars) # <<<<<<<<<<<<<< + * + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + */ + __pyx_t_1 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2810, __pyx_L1_error) + __pyx_v_nvars = __pyx_t_1; + + /* "src/pyscipopt/scip.pxi":2812 + * nvars = len(vars) + * + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) # <<<<<<<<<<<<<< + * for idx, var in enumerate(vars): + * _vars[idx] = (var).scip_var + */ + __pyx_t_1 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2812, __pyx_L1_error) + __pyx_v__vars = ((SCIP_VAR **)malloc((__pyx_t_1 * (sizeof(SCIP_VAR *))))); + + /* "src/pyscipopt/scip.pxi":2813 + * + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): # <<<<<<<<<<<<<< + * _vars[idx] = (var).scip_var + * _resVar = (resvar).scip_var + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_2 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_vars)) || PyTuple_CheckExact(__pyx_v_vars)) { + __pyx_t_3 = __pyx_v_vars; __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_vars); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2813, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2813, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 2813, __pyx_L1_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2813, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 2813, __pyx_L1_error) + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_3); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2813, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_2); + __pyx_t_5 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2814 + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): + * _vars[idx] = (var).scip_var # <<<<<<<<<<<<<< + * _resVar = (resvar).scip_var + * + */ + __pyx_t_6 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_var)->scip_var; + __pyx_t_7 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_7 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2814, __pyx_L1_error) + (__pyx_v__vars[__pyx_t_7]) = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":2813 + * + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): # <<<<<<<<<<<<<< + * _vars[idx] = (var).scip_var + * _resVar = (resvar).scip_var + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2815 + * for idx, var in enumerate(vars): + * _vars[idx] = (var).scip_var + * _resVar = (resvar).scip_var # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPcreateConsOr(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars, + */ + __pyx_t_6 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_resvar)->scip_var; + __pyx_v__resVar = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":2817 + * _resVar = (resvar).scip_var + * + * PY_SCIP_CALL(SCIPcreateConsOr(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2817, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2817, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_name}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2817, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_t_5); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) __PYX_ERR(0, 2817, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2818 + * + * PY_SCIP_CALL(SCIPcreateConsOr(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars, + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + */ + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_separate); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_propagate); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_17 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_modifiable); if (unlikely((__pyx_t_18 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_19 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_v_stickingatnode); if (unlikely((__pyx_t_21 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2818, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2817 + * _resVar = (resvar).scip_var + * + * PY_SCIP_CALL(SCIPcreateConsOr(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + */ + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsOr(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_11, __pyx_v__resVar, __pyx_v_nvars, __pyx_v__vars, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2817, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2817, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2820 + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) # <<<<<<<<<<<<<< + * pyCons = Constraint.create(scip_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_scip_cons)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2821 + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_pyCons = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2822 + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pyCons = Constraint.create(scip_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) # <<<<<<<<<<<<<< + * + * free(_vars) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&__pyx_v_scip_cons))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_8}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2824 + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + * free(_vars) # <<<<<<<<<<<<<< + * + * return pyCons + */ + free(__pyx_v__vars); + + /* "src/pyscipopt/scip.pxi":2826 + * free(_vars) + * + * return pyCons # <<<<<<<<<<<<<< + * + * def addConsXor(self, vars, rhsvar, name="XORcons", + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyCons); + __pyx_r = __pyx_v_pyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2789 + * return pyCons + * + * def addConsOr(self, vars, resvar, name="ORcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsOr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XDECREF(__pyx_v_pyCons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2828 + * return pyCons + * + * def addConsXor(self, vars, rhsvar, name="XORcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_295addConsXor(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_294addConsXor, "Model.addConsXor(self, vars, rhsvar, name=u'XORcons', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False)\nAdd a XOR-constraint.\n :param vars: list of BINARY variables to be included (operators)\n :param rhsvar: BOOLEAN value, explicit True, False or bool(obj) is needed (right-hand side)\n :param name: name of the constraint (Default value = \"XORcons\")\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: should the constraint be propagated during node processing? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_295addConsXor = {"addConsXor", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_295addConsXor, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_294addConsXor}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_295addConsXor(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_vars = 0; + PyObject *__pyx_v_rhsvar = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[13] = {0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsXor (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_vars,&__pyx_n_s_rhsvar,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_XORcons)); + + /* "src/pyscipopt/scip.pxi":2829 + * + * def addConsXor(self, vars, rhsvar, name="XORcons", + * initial=True, separate=True, enforce=True, check=True, # <<<<<<<<<<<<<< + * propagate=True, local=False, modifiable=False, dynamic=False, + * removable=False, stickingatnode=False): + */ + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2830 + * def addConsXor(self, vars, rhsvar, name="XORcons", + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, # <<<<<<<<<<<<<< + * removable=False, stickingatnode=False): + * """Add a XOR-constraint. + */ + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2831 + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + * removable=False, stickingatnode=False): # <<<<<<<<<<<<<< + * """Add a XOR-constraint. + * :param vars: list of BINARY variables to be included (operators) + */ + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[12] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_vars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rhsvar)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addConsXor", 0, 2, 13, 1); __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[12] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2828, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsXor") < 0)) __PYX_ERR(0, 2828, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_vars = values[0]; + __pyx_v_rhsvar = values[1]; + __pyx_v_name = values[2]; + __pyx_v_initial = values[3]; + __pyx_v_separate = values[4]; + __pyx_v_enforce = values[5]; + __pyx_v_check = values[6]; + __pyx_v_propagate = values[7]; + __pyx_v_local = values[8]; + __pyx_v_modifiable = values[9]; + __pyx_v_dynamic = values[10]; + __pyx_v_removable = values[11]; + __pyx_v_stickingatnode = values[12]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsXor", 0, 2, 13, __pyx_nargs); __PYX_ERR(0, 2828, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsXor", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_294addConsXor(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_vars, __pyx_v_rhsvar, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_modifiable, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2828 + * return pyCons + * + * def addConsXor(self, vars, rhsvar, name="XORcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_294addConsXor(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_vars, PyObject *__pyx_v_rhsvar, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + SCIP_CONS *__pyx_v_scip_cons; + Py_ssize_t __pyx_v_nvars; + SCIP_VAR **__pyx_v__vars; + PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_v_pyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *(*__pyx_t_5)(PyObject *); + PyObject *__pyx_t_6 = NULL; + SCIP_VAR *__pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + char const *__pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + SCIP_Bool __pyx_t_17; + SCIP_Bool __pyx_t_18; + SCIP_Bool __pyx_t_19; + SCIP_Bool __pyx_t_20; + SCIP_Bool __pyx_t_21; + SCIP_Bool __pyx_t_22; + SCIP_Bool __pyx_t_23; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsXor", 1); + + /* "src/pyscipopt/scip.pxi":2849 + * cdef SCIP_CONS* scip_cons + * + * nvars = len(vars) # <<<<<<<<<<<<<< + * + * assert type(rhsvar) is type(bool()), "Provide BOOLEAN value as rhsvar, you gave %s." % type(rhsvar) + */ + __pyx_t_1 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2849, __pyx_L1_error) + __pyx_v_nvars = __pyx_t_1; + + /* "src/pyscipopt/scip.pxi":2851 + * nvars = len(vars) + * + * assert type(rhsvar) is type(bool()), "Provide BOOLEAN value as rhsvar, you gave %s." % type(rhsvar) # <<<<<<<<<<<<<< + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_2 = (((PyObject *)Py_TYPE(__pyx_v_rhsvar)) == ((PyObject *)Py_TYPE(Py_False))); + if (unlikely(!__pyx_t_2)) { + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_Provide_BOOLEAN_value_as_rhsvar, ((PyObject *)Py_TYPE(__pyx_v_rhsvar))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_3, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 2851, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2851, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2852 + * + * assert type(rhsvar) is type(bool()), "Provide BOOLEAN value as rhsvar, you gave %s." % type(rhsvar) + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) # <<<<<<<<<<<<<< + * for idx, var in enumerate(vars): + * _vars[idx] = (var).scip_var + */ + __pyx_t_1 = PyObject_Length(__pyx_v_vars); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2852, __pyx_L1_error) + __pyx_v__vars = ((SCIP_VAR **)malloc((__pyx_t_1 * (sizeof(SCIP_VAR *))))); + + /* "src/pyscipopt/scip.pxi":2853 + * assert type(rhsvar) is type(bool()), "Provide BOOLEAN value as rhsvar, you gave %s." % type(rhsvar) + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): # <<<<<<<<<<<<<< + * _vars[idx] = (var).scip_var + * + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_vars)) || PyTuple_CheckExact(__pyx_v_vars)) { + __pyx_t_4 = __pyx_v_vars; __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = 0; + __pyx_t_5 = NULL; + } else { + __pyx_t_1 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_vars); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2853, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_5)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2853, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 2853, __pyx_L1_error) + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2853, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely((0 < 0))) __PYX_ERR(0, 2853, __pyx_L1_error) + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + } + } else { + __pyx_t_6 = __pyx_t_5(__pyx_t_4); + if (unlikely(!__pyx_t_6)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2853, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_6); + } + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_6); + __pyx_t_6 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); + __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":2854 + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): + * _vars[idx] = (var).scip_var # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPcreateConsXor(self._scip, &scip_cons, str_conversion(name), rhsvar, nvars, _vars, + */ + __pyx_t_7 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_var)->scip_var; + __pyx_t_8 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_8 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2854, __pyx_L1_error) + (__pyx_v__vars[__pyx_t_8]) = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":2853 + * assert type(rhsvar) is type(bool()), "Provide BOOLEAN value as rhsvar, you gave %s." % type(rhsvar) + * _vars = malloc(len(vars) * sizeof(SCIP_VAR*)) + * for idx, var in enumerate(vars): # <<<<<<<<<<<<<< + * _vars[idx] = (var).scip_var + * + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2856 + * _vars[idx] = (var).scip_var + * + * PY_SCIP_CALL(SCIPcreateConsXor(self._scip, &scip_cons, str_conversion(name), rhsvar, nvars, _vars, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_9); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_9, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_v_name}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_9, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __pyx_t_12 = __Pyx_PyObject_AsString(__pyx_t_6); if (unlikely((!__pyx_t_12) && PyErr_Occurred())) __PYX_ERR(0, 2856, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_rhsvar); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2856, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2857 + * + * PY_SCIP_CALL(SCIPcreateConsXor(self._scip, &scip_cons, str_conversion(name), rhsvar, nvars, _vars, + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + */ + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_separate); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_17 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_propagate); if (unlikely((__pyx_t_18 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_19 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_modifiable); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_21 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_22 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_IsTrue(__pyx_v_stickingatnode); if (unlikely((__pyx_t_23 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2856 + * _vars[idx] = (var).scip_var + * + * PY_SCIP_CALL(SCIPcreateConsXor(self._scip, &scip_cons, str_conversion(name), rhsvar, nvars, _vars, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + */ + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsXor(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_12, __pyx_t_13, __pyx_v_nvars, __pyx_v__vars, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_t_23)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_9}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2859 + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) # <<<<<<<<<<<<<< + * pyCons = Constraint.create(scip_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_scip_cons)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_9}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2860 + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + */ + __pyx_t_3 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2860, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_pyCons = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2861 + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pyCons = Constraint.create(scip_cons) + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) # <<<<<<<<<<<<<< + * + * free(_vars) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2861, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&__pyx_v_scip_cons))); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2861, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_9}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2861, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2863 + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + * free(_vars) # <<<<<<<<<<<<<< + * + * return pyCons + */ + free(__pyx_v__vars); + + /* "src/pyscipopt/scip.pxi":2865 + * free(_vars) + * + * return pyCons # <<<<<<<<<<<<<< + * + * def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons", + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyCons); + __pyx_r = __pyx_v_pyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2828 + * return pyCons + * + * def addConsXor(self, vars, rhsvar, name="XORcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsXor", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XDECREF(__pyx_v_pyCons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2867 + * return pyCons + * + * def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_297addConsCardinality(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_296addConsCardinality, "Model.addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name=u'CardinalityCons', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, dynamic=False, removable=False, stickingatnode=False)\nAdd a cardinality constraint that allows at most 'cardval' many nonzero variables.\n\n :param consvars: list of variables to be included\n :param cardval: nonnegative integer\n :param indvars: indicator variables indicating which variables may be treated as nonzero in cardinality constraint, or None if new indicator variables should be introduced automatically (Default value = None)\n :param weights: weights determining the variable order, or None if variables should be ordered in the same way they were added to the constraint (Default value = None)\n :param name: name of the constraint (Default value = \"CardinalityCons\")\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: should the constraint be propagated during node processing? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_297addConsCardinality = {"addConsCardinality", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_297addConsCardinality, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_296addConsCardinality}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_297addConsCardinality(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_consvars = 0; + PyObject *__pyx_v_cardval = 0; + PyObject *__pyx_v_indvars = 0; + PyObject *__pyx_v_weights = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[14] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsCardinality (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_consvars,&__pyx_n_s_cardval,&__pyx_n_s_indvars,&__pyx_n_s_weights,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_CardinalityCons)); + + /* "src/pyscipopt/scip.pxi":2868 + * + * def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons", + * initial=True, separate=True, enforce=True, check=True, # <<<<<<<<<<<<<< + * propagate=True, local=False, dynamic=False, + * removable=False, stickingatnode=False): + */ + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2869 + * def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons", + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, # <<<<<<<<<<<<<< + * removable=False, stickingatnode=False): + * """Add a cardinality constraint that allows at most 'cardval' many nonzero variables. + */ + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2870 + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + * removable=False, stickingatnode=False): # <<<<<<<<<<<<<< + * """Add a cardinality constraint that allows at most 'cardval' many nonzero variables. + * + */ + values[12] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[13] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 14: values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_consvars)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cardval)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addConsCardinality", 0, 2, 14, 1); __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_indvars); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_weights); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[12] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 13: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[13] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2867, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsCardinality") < 0)) __PYX_ERR(0, 2867, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 14: values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_consvars = values[0]; + __pyx_v_cardval = values[1]; + __pyx_v_indvars = values[2]; + __pyx_v_weights = values[3]; + __pyx_v_name = values[4]; + __pyx_v_initial = values[5]; + __pyx_v_separate = values[6]; + __pyx_v_enforce = values[7]; + __pyx_v_check = values[8]; + __pyx_v_propagate = values[9]; + __pyx_v_local = values[10]; + __pyx_v_dynamic = values[11]; + __pyx_v_removable = values[12]; + __pyx_v_stickingatnode = values[13]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsCardinality", 0, 2, 14, __pyx_nargs); __PYX_ERR(0, 2867, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsCardinality", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_296addConsCardinality(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_consvars, __pyx_v_cardval, __pyx_v_indvars, __pyx_v_weights, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2867 + * return pyCons + * + * def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_296addConsCardinality(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_consvars, PyObject *__pyx_v_cardval, PyObject *__pyx_v_indvars, PyObject *__pyx_v_weights, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + SCIP_CONS *__pyx_v_scip_cons; + SCIP_VAR *__pyx_v_indvar; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_v = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + PyObject *__pyx_v_pyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + char const *__pyx_t_7; + SCIP_Bool __pyx_t_8; + SCIP_Bool __pyx_t_9; + SCIP_Bool __pyx_t_10; + SCIP_Bool __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + int __pyx_t_17; + Py_ssize_t __pyx_t_18; + PyObject *(*__pyx_t_19)(PyObject *); + SCIP_VAR *__pyx_t_20; + PyObject *__pyx_t_21 = NULL; + SCIP_Real __pyx_t_22; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsCardinality", 0); + __Pyx_INCREF(__pyx_v_weights); + + /* "src/pyscipopt/scip.pxi":2892 + * cdef SCIP_VAR* indvar + * + * PY_SCIP_CALL(SCIPcreateConsCardinality(self._scip, &scip_cons, str_conversion(name), 0, NULL, cardval, NULL, NULL, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_name}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_t_3); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 2892, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_cardval); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2892, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2893 + * + * PY_SCIP_CALL(SCIPcreateConsCardinality(self._scip, &scip_cons, str_conversion(name), 0, NULL, cardval, NULL, NULL, + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) # <<<<<<<<<<<<<< + * + * # circumvent an annoying bug in SCIP 4.0.0 that does not allow uninitialized weights + */ + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_separate); if (unlikely((__pyx_t_9 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_propagate); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_stickingatnode); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2893, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2892 + * cdef SCIP_VAR* indvar + * + * PY_SCIP_CALL(SCIPcreateConsCardinality(self._scip, &scip_cons, str_conversion(name), 0, NULL, cardval, NULL, NULL, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * + */ + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsCardinality(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_7, 0, NULL, __pyx_t_6, NULL, NULL, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2896 + * + * # circumvent an annoying bug in SCIP 4.0.0 that does not allow uninitialized weights + * if weights is None: # <<<<<<<<<<<<<< + * weights = list(range(1, len(consvars) + 1)) + * + */ + __pyx_t_17 = (__pyx_v_weights == Py_None); + if (__pyx_t_17) { + + /* "src/pyscipopt/scip.pxi":2897 + * # circumvent an annoying bug in SCIP 4.0.0 that does not allow uninitialized weights + * if weights is None: + * weights = list(range(1, len(consvars) + 1)) # <<<<<<<<<<<<<< + * + * for i, v in enumerate(consvars): + */ + __pyx_t_18 = PyObject_Length(__pyx_v_consvars); if (unlikely(__pyx_t_18 == ((Py_ssize_t)-1))) __PYX_ERR(0, 2897, __pyx_L1_error) + __pyx_t_1 = PyInt_FromSsize_t((__pyx_t_18 + 1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_int_1); + __Pyx_GIVEREF(__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_1)) __PYX_ERR(0, 2897, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 2897, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PySequence_ListKeepNew(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_weights, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2896 + * + * # circumvent an annoying bug in SCIP 4.0.0 that does not allow uninitialized weights + * if weights is None: # <<<<<<<<<<<<<< + * weights = list(range(1, len(consvars) + 1)) + * + */ + } + + /* "src/pyscipopt/scip.pxi":2899 + * weights = list(range(1, len(consvars) + 1)) + * + * for i, v in enumerate(consvars): # <<<<<<<<<<<<<< + * var = v + * if indvars: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_2 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_consvars)) || PyTuple_CheckExact(__pyx_v_consvars)) { + __pyx_t_1 = __pyx_v_consvars; __Pyx_INCREF(__pyx_t_1); + __pyx_t_18 = 0; + __pyx_t_19 = NULL; + } else { + __pyx_t_18 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_consvars); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_19 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 2899, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_19)) { + if (likely(PyList_CheckExact(__pyx_t_1))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2899, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_18); __Pyx_INCREF(__pyx_t_4); __pyx_t_18++; if (unlikely((0 < 0))) __PYX_ERR(0, 2899, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_18); __pyx_t_18++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 2899, __pyx_L1_error) + #endif + if (__pyx_t_18 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_18); __Pyx_INCREF(__pyx_t_4); __pyx_t_18++; if (unlikely((0 < 0))) __PYX_ERR(0, 2899, __pyx_L1_error) + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_18); __pyx_t_18++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + } + } else { + __pyx_t_4 = __pyx_t_19(__pyx_t_1); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 2899, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":2900 + * + * for i, v in enumerate(consvars): + * var = v # <<<<<<<<<<<<<< + * if indvars: + * indvar = (indvars[i]).scip_var + */ + __pyx_t_4 = __pyx_v_v; + __Pyx_INCREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":2901 + * for i, v in enumerate(consvars): + * var = v + * if indvars: # <<<<<<<<<<<<<< + * indvar = (indvars[i]).scip_var + * else: + */ + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_indvars); if (unlikely((__pyx_t_17 < 0))) __PYX_ERR(0, 2901, __pyx_L1_error) + if (__pyx_t_17) { + + /* "src/pyscipopt/scip.pxi":2902 + * var = v + * if indvars: + * indvar = (indvars[i]).scip_var # <<<<<<<<<<<<<< + * else: + * indvar = NULL + */ + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_indvars, __pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2902, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_20 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_4)->scip_var; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_indvar = __pyx_t_20; + + /* "src/pyscipopt/scip.pxi":2901 + * for i, v in enumerate(consvars): + * var = v + * if indvars: # <<<<<<<<<<<<<< + * indvar = (indvars[i]).scip_var + * else: + */ + goto __pyx_L6; + } + + /* "src/pyscipopt/scip.pxi":2904 + * indvar = (indvars[i]).scip_var + * else: + * indvar = NULL # <<<<<<<<<<<<<< + * if weights is None: + * PY_SCIP_CALL(SCIPappendVarCardinality(self._scip, scip_cons, var.scip_var, indvar)) + */ + /*else*/ { + __pyx_v_indvar = NULL; + } + __pyx_L6:; + + /* "src/pyscipopt/scip.pxi":2905 + * else: + * indvar = NULL + * if weights is None: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPappendVarCardinality(self._scip, scip_cons, var.scip_var, indvar)) + * else: + */ + __pyx_t_17 = (__pyx_v_weights == Py_None); + if (__pyx_t_17) { + + /* "src/pyscipopt/scip.pxi":2906 + * indvar = NULL + * if weights is None: + * PY_SCIP_CALL(SCIPappendVarCardinality(self._scip, scip_cons, var.scip_var, indvar)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPaddVarCardinality(self._scip, scip_cons, var.scip_var, indvar, weights[i])) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2906, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPappendVarCardinality(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_var->scip_var, __pyx_v_indvar)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2906, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_21 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_21)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_21); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_21, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2906, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":2905 + * else: + * indvar = NULL + * if weights is None: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPappendVarCardinality(self._scip, scip_cons, var.scip_var, indvar)) + * else: + */ + goto __pyx_L7; + } + + /* "src/pyscipopt/scip.pxi":2908 + * PY_SCIP_CALL(SCIPappendVarCardinality(self._scip, scip_cons, var.scip_var, indvar)) + * else: + * PY_SCIP_CALL(SCIPaddVarCardinality(self._scip, scip_cons, var.scip_var, indvar, weights[i])) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2908, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_weights, __pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2908, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_22 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_22 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2908, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVarCardinality(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_var->scip_var, __pyx_v_indvar, ((SCIP_Real)__pyx_t_22))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2908, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_21 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_21)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_21); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_21, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2908, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L7:; + + /* "src/pyscipopt/scip.pxi":2899 + * weights = list(range(1, len(consvars) + 1)) + * + * for i, v in enumerate(consvars): # <<<<<<<<<<<<<< + * var = v + * if indvars: + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2910 + * PY_SCIP_CALL(SCIPaddVarCardinality(self._scip, scip_cons, var.scip_var, indvar, weights[i])) + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) # <<<<<<<<<<<<<< + * pyCons = Constraint.create(scip_cons) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2910, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_scip_cons)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2910, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2910, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2911 + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_pyCons = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2913 + * pyCons = Constraint.create(scip_cons) + * + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) # <<<<<<<<<<<<<< + * + * return pyCons + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&__pyx_v_scip_cons))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":2915 + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + * return pyCons # <<<<<<<<<<<<<< + * + * def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons", + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyCons); + __pyx_r = __pyx_v_pyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2867 + * return pyCons + * + * def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_21); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsCardinality", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XDECREF(__pyx_v_pyCons); + __Pyx_XDECREF(__pyx_v_weights); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2917 + * return pyCons + * + * def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_299addConsIndicator(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_298addConsIndicator, "Model.addConsIndicator(self, cons, binvar=None, activeone=True, name=u'IndicatorCons', initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, dynamic=False, removable=False, stickingatnode=False)\nAdd an indicator constraint for the linear inequality 'cons'.\n\n The 'binvar' argument models the redundancy of the linear constraint. A solution for which\n 'binvar' is 1 must satisfy the constraint.\n\n :param cons: a linear inequality of the form \"<=\"\n :param binvar: binary indicator variable, or None if it should be created (Default value = None)\n :param activeone: constraint should active if binvar is 1 (0 if activeone = False)\n :param name: name of the constraint (Default value = \"IndicatorCons\")\n :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)\n :param separate: should the constraint be separated during LP processing? (Default value = True)\n :param enforce: should the constraint be enforced during node processing? (Default value = True)\n :param check: should the constraint be checked for feasibility? (Default value = True)\n :param propagate: should the constraint be propagated during node processing? (Default value = True)\n :param local: is the constraint only valid locally? (Default value = False)\n :param dynamic: is the constraint subject to aging? (Default value = False)\n :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)\n :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_299addConsIndicator = {"addConsIndicator", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_299addConsIndicator, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_298addConsIndicator}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_299addConsIndicator(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_cons = 0; + PyObject *__pyx_v_binvar = 0; + PyObject *__pyx_v_activeone = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[13] = {0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addConsIndicator (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_binvar,&__pyx_n_s_activeone,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_IndicatorCons)); + + /* "src/pyscipopt/scip.pxi":2918 + * + * def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons", + * initial=True, separate=True, enforce=True, check=True, # <<<<<<<<<<<<<< + * propagate=True, local=False, dynamic=False, + * removable=False, stickingatnode=False): + */ + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":2919 + * def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons", + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, # <<<<<<<<<<<<<< + * removable=False, stickingatnode=False): + * """Add an indicator constraint for the linear inequality 'cons'. + */ + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":2920 + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + * removable=False, stickingatnode=False): # <<<<<<<<<<<<<< + * """Add an indicator constraint for the linear inequality 'cons'. + * + */ + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[12] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_binvar); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_activeone); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[12] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2917, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addConsIndicator") < 0)) __PYX_ERR(0, 2917, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cons = values[0]; + __pyx_v_binvar = values[1]; + __pyx_v_activeone = values[2]; + __pyx_v_name = values[3]; + __pyx_v_initial = values[4]; + __pyx_v_separate = values[5]; + __pyx_v_enforce = values[6]; + __pyx_v_check = values[7]; + __pyx_v_propagate = values[8]; + __pyx_v_local = values[9]; + __pyx_v_dynamic = values[10]; + __pyx_v_removable = values[11]; + __pyx_v_stickingatnode = values[12]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addConsIndicator", 0, 1, 13, __pyx_nargs); __PYX_ERR(0, 2917, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsIndicator", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_298addConsIndicator(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_binvar, __pyx_v_activeone, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":2917 + * return pyCons + * + * def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_298addConsIndicator(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_cons, PyObject *__pyx_v_binvar, PyObject *__pyx_v_activeone, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + SCIP_CONS *__pyx_v_scip_cons; + SCIP_VAR *__pyx_v__binVar; + PyObject *__pyx_v_rhs = NULL; + int __pyx_v_negate; + PyObject *__pyx_v_terms = NULL; + PyObject *__pyx_v_key = NULL; + PyObject *__pyx_v_coeff = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + PyObject *__pyx_v_pyCons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + SCIP_VAR *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + char const *__pyx_t_10; + SCIP_Real __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + SCIP_Bool __pyx_t_17; + SCIP_Bool __pyx_t_18; + SCIP_Bool __pyx_t_19; + SCIP_Bool __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + int __pyx_t_23; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addConsIndicator", 1); + + /* "src/pyscipopt/scip.pxi":2941 + * + * """ + * assert isinstance(cons, ExprCons), "given constraint is not ExprCons but %s" % cons.__class__.__name__ # <<<<<<<<<<<<<< + * cdef SCIP_CONS* scip_cons + * cdef SCIP_VAR* _binVar + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_cons, __pyx_ptype_9pyscipopt_4scip_ExprCons); + if (unlikely(!__pyx_t_1)) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_given_constraint_is_not_ExprCons, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_2, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2941, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 2941, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":2944 + * cdef SCIP_CONS* scip_cons + * cdef SCIP_VAR* _binVar + * if cons._lhs is not None and cons._rhs is not None: # <<<<<<<<<<<<<< + * raise ValueError("expected inequality that has either only a left or right hand side") + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_lhs_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_t_2 != Py_None); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_4) { + } else { + __pyx_t_1 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_rhs_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_t_2 != Py_None); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":2945 + * cdef SCIP_VAR* _binVar + * if cons._lhs is not None and cons._rhs is not None: + * raise ValueError("expected inequality that has either only a left or right hand side") # <<<<<<<<<<<<<< + * + * if cons.expr.degree() > 1: + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 2945, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2944 + * cdef SCIP_CONS* scip_cons + * cdef SCIP_VAR* _binVar + * if cons._lhs is not None and cons._rhs is not None: # <<<<<<<<<<<<<< + * raise ValueError("expected inequality that has either only a left or right hand side") + * + */ + } + + /* "src/pyscipopt/scip.pxi":2947 + * raise ValueError("expected inequality that has either only a left or right hand side") + * + * if cons.expr.degree() > 1: # <<<<<<<<<<<<<< + * raise ValueError("expected linear inequality, expression has degree %d" % cons.expr.degree()) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_expr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_degree); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_int_1, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2947, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2947, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":2948 + * + * if cons.expr.degree() > 1: + * raise ValueError("expected linear inequality, expression has degree %d" % cons.expr.degree()) # <<<<<<<<<<<<<< + * + * if cons._rhs is not None: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_expr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_degree); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_expected_linear_inequality_expre, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 2948, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2947 + * raise ValueError("expected inequality that has either only a left or right hand side") + * + * if cons.expr.degree() > 1: # <<<<<<<<<<<<<< + * raise ValueError("expected linear inequality, expression has degree %d" % cons.expr.degree()) + * + */ + } + + /* "src/pyscipopt/scip.pxi":2950 + * raise ValueError("expected linear inequality, expression has degree %d" % cons.expr.degree()) + * + * if cons._rhs is not None: # <<<<<<<<<<<<<< + * rhs = cons._rhs + * negate = False + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_rhs_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2950, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = (__pyx_t_5 != Py_None); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":2951 + * + * if cons._rhs is not None: + * rhs = cons._rhs # <<<<<<<<<<<<<< + * negate = False + * else: + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_rhs_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_rhs = __pyx_t_5; + __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2952 + * if cons._rhs is not None: + * rhs = cons._rhs + * negate = False # <<<<<<<<<<<<<< + * else: + * rhs = -cons._lhs + */ + __pyx_v_negate = 0; + + /* "src/pyscipopt/scip.pxi":2950 + * raise ValueError("expected linear inequality, expression has degree %d" % cons.expr.degree()) + * + * if cons._rhs is not None: # <<<<<<<<<<<<<< + * rhs = cons._rhs + * negate = False + */ + goto __pyx_L7; + } + + /* "src/pyscipopt/scip.pxi":2954 + * negate = False + * else: + * rhs = -cons._lhs # <<<<<<<<<<<<<< + * negate = True + * + */ + /*else*/ { + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_lhs_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PyNumber_Negative(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_rhs = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2955 + * else: + * rhs = -cons._lhs + * negate = True # <<<<<<<<<<<<<< + * + * if binvar is not None: + */ + __pyx_v_negate = 1; + } + __pyx_L7:; + + /* "src/pyscipopt/scip.pxi":2957 + * negate = True + * + * if binvar is not None: # <<<<<<<<<<<<<< + * _binVar = (binvar).scip_var + * if not activeone: + */ + __pyx_t_1 = (__pyx_v_binvar != Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":2958 + * + * if binvar is not None: + * _binVar = (binvar).scip_var # <<<<<<<<<<<<<< + * if not activeone: + * PY_SCIP_CALL(SCIPgetNegatedVar(self._scip, _binVar, &_binVar)) + */ + __pyx_t_7 = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_binvar)->scip_var; + __pyx_v__binVar = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":2959 + * if binvar is not None: + * _binVar = (binvar).scip_var + * if not activeone: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPgetNegatedVar(self._scip, _binVar, &_binVar)) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_activeone); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 2959, __pyx_L1_error) + __pyx_t_4 = (!__pyx_t_1); + if (__pyx_t_4) { + + /* "src/pyscipopt/scip.pxi":2960 + * _binVar = (binvar).scip_var + * if not activeone: + * PY_SCIP_CALL(SCIPgetNegatedVar(self._scip, _binVar, &_binVar)) # <<<<<<<<<<<<<< + * else: + * _binVar = NULL + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetNegatedVar(__pyx_v_self->_scip, __pyx_v__binVar, (&__pyx_v__binVar))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2959 + * if binvar is not None: + * _binVar = (binvar).scip_var + * if not activeone: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPgetNegatedVar(self._scip, _binVar, &_binVar)) + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":2957 + * negate = True + * + * if binvar is not None: # <<<<<<<<<<<<<< + * _binVar = (binvar).scip_var + * if not activeone: + */ + goto __pyx_L8; + } + + /* "src/pyscipopt/scip.pxi":2962 + * PY_SCIP_CALL(SCIPgetNegatedVar(self._scip, _binVar, &_binVar)) + * else: + * _binVar = NULL # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPcreateConsIndicator(self._scip, &scip_cons, str_conversion(name), _binVar, 0, NULL, NULL, rhs, + */ + /*else*/ { + __pyx_v__binVar = NULL; + } + __pyx_L8:; + + /* "src/pyscipopt/scip.pxi":2964 + * _binVar = NULL + * + * PY_SCIP_CALL(SCIPcreateConsIndicator(self._scip, &scip_cons, str_conversion(name), _binVar, 0, NULL, NULL, rhs, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * terms = cons.expr.terms + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_t_2); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 2964, __pyx_L1_error) + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_v_rhs); if (unlikely((__pyx_t_11 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2964, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2965 + * + * PY_SCIP_CALL(SCIPcreateConsIndicator(self._scip, &scip_cons, str_conversion(name), _binVar, 0, NULL, NULL, rhs, + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) # <<<<<<<<<<<<<< + * terms = cons.expr.terms + * + */ + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_separate); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_propagate); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_17 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_18 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_19 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_stickingatnode); if (unlikely((__pyx_t_20 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2965, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2964 + * _binVar = NULL + * + * PY_SCIP_CALL(SCIPcreateConsIndicator(self._scip, &scip_cons, str_conversion(name), _binVar, 0, NULL, NULL, rhs, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * terms = cons.expr.terms + */ + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateConsIndicator(__pyx_v_self->_scip, (&__pyx_v_scip_cons), __pyx_t_10, __pyx_v__binVar, 0, NULL, NULL, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2966 + * PY_SCIP_CALL(SCIPcreateConsIndicator(self._scip, &scip_cons, str_conversion(name), _binVar, 0, NULL, NULL, rhs, + * initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode)) + * terms = cons.expr.terms # <<<<<<<<<<<<<< + * + * for key, coeff in terms.items(): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_cons, __pyx_n_s_expr); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2966, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_terms); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2966, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_terms = __pyx_t_5; + __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2968 + * terms = cons.expr.terms + * + * for key, coeff in terms.items(): # <<<<<<<<<<<<<< + * var = key[0] + * if negate: + */ + __pyx_t_21 = 0; + if (unlikely(__pyx_v_terms == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 2968, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_dict_iterator(__pyx_v_terms, 0, __pyx_n_s_items, (&__pyx_t_22), (&__pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __pyx_t_5 = __pyx_t_3; + __pyx_t_3 = 0; + while (1) { + __pyx_t_23 = __Pyx_dict_iter_next(__pyx_t_5, __pyx_t_22, &__pyx_t_21, &__pyx_t_3, &__pyx_t_8, NULL, __pyx_t_6); + if (unlikely(__pyx_t_23 == 0)) break; + if (unlikely(__pyx_t_23 == -1)) __PYX_ERR(0, 2968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_coeff, __pyx_t_8); + __pyx_t_8 = 0; + + /* "src/pyscipopt/scip.pxi":2969 + * + * for key, coeff in terms.items(): + * var = key[0] # <<<<<<<<<<<<<< + * if negate: + * coeff = -coeff + */ + __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_key, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2970 + * for key, coeff in terms.items(): + * var = key[0] + * if negate: # <<<<<<<<<<<<<< + * coeff = -coeff + * PY_SCIP_CALL(SCIPaddVarIndicator(self._scip, scip_cons, var.scip_var, coeff)) + */ + if (__pyx_v_negate) { + + /* "src/pyscipopt/scip.pxi":2971 + * var = key[0] + * if negate: + * coeff = -coeff # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddVarIndicator(self._scip, scip_cons, var.scip_var, coeff)) + * + */ + __pyx_t_3 = PyNumber_Negative(__pyx_v_coeff); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_coeff, __pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":2970 + * for key, coeff in terms.items(): + * var = key[0] + * if negate: # <<<<<<<<<<<<<< + * coeff = -coeff + * PY_SCIP_CALL(SCIPaddVarIndicator(self._scip, scip_cons, var.scip_var, coeff)) + */ + } + + /* "src/pyscipopt/scip.pxi":2972 + * if negate: + * coeff = -coeff + * PY_SCIP_CALL(SCIPaddVarIndicator(self._scip, scip_cons, var.scip_var, coeff)) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_v_coeff); if (unlikely((__pyx_t_11 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 2972, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVarIndicator(__pyx_v_self->_scip, __pyx_v_scip_cons, __pyx_v_var->scip_var, ((SCIP_Real)__pyx_t_11))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = NULL; + __pyx_t_23 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_23 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_2}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_23, 1+__pyx_t_23); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2974 + * PY_SCIP_CALL(SCIPaddVarIndicator(self._scip, scip_cons, var.scip_var, coeff)) + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) # <<<<<<<<<<<<<< + * pyCons = Constraint.create(scip_cons) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_scip_cons)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_8}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2974, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2975 + * + * PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons)) + * pyCons = Constraint.create(scip_cons) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + */ + __pyx_t_5 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_scip_cons); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2975, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_pyCons = __pyx_t_5; + __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2977 + * pyCons = Constraint.create(scip_cons) + * + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) # <<<<<<<<<<<<<< + * + * return pyCons + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreleaseCons(__pyx_v_self->_scip, (&__pyx_v_scip_cons))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_8}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":2979 + * PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons)) + * + * return pyCons # <<<<<<<<<<<<<< + * + * def getSlackVarIndicator(self, Constraint cons): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_pyCons); + __pyx_r = __pyx_v_pyCons; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2917 + * return pyCons + * + * def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.addConsIndicator", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XDECREF(__pyx_v_terms); + __Pyx_XDECREF(__pyx_v_key); + __Pyx_XDECREF(__pyx_v_coeff); + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XDECREF(__pyx_v_pyCons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2981 + * return pyCons + * + * def getSlackVarIndicator(self, Constraint cons): # <<<<<<<<<<<<<< + * """Get slack variable of an indicator constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_301getSlackVarIndicator(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_300getSlackVarIndicator, "Model.getSlackVarIndicator(self, Constraint cons)\nGet slack variable of an indicator constraint.\n\n :param Constraint cons: indicator constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_301getSlackVarIndicator = {"getSlackVarIndicator", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_301getSlackVarIndicator, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_300getSlackVarIndicator}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_301getSlackVarIndicator(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getSlackVarIndicator (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2981, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getSlackVarIndicator") < 0)) __PYX_ERR(0, 2981, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getSlackVarIndicator", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2981, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getSlackVarIndicator", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 2981, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_300getSlackVarIndicator(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_300getSlackVarIndicator(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + SCIP_VAR *__pyx_v_var; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getSlackVarIndicator", 1); + + /* "src/pyscipopt/scip.pxi":2987 + * + * """ + * cdef SCIP_VAR* var = SCIPgetSlackVarIndicator(cons.scip_cons); # <<<<<<<<<<<<<< + * return Variable.create(var) + * + */ + __pyx_v_var = SCIPgetSlackVarIndicator(__pyx_v_cons->scip_cons); + + /* "src/pyscipopt/scip.pxi":2988 + * """ + * cdef SCIP_VAR* var = SCIPgetSlackVarIndicator(cons.scip_cons); + * return Variable.create(var) # <<<<<<<<<<<<<< + * + * def addPyCons(self, Constraint cons): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v_var); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2988, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":2981 + * return pyCons + * + * def getSlackVarIndicator(self, Constraint cons): # <<<<<<<<<<<<<< + * """Get slack variable of an indicator constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getSlackVarIndicator", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2990 + * return Variable.create(var) + * + * def addPyCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Adds a customly created cons. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_303addPyCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_302addPyCons, "Model.addPyCons(self, Constraint cons)\nAdds a customly created cons.\n\n :param Constraint cons: constraint to add\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_303addPyCons = {"addPyCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_303addPyCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_302addPyCons}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_303addPyCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addPyCons (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2990, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addPyCons") < 0)) __PYX_ERR(0, 2990, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addPyCons", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 2990, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addPyCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 2990, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_302addPyCons(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_302addPyCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addPyCons", 1); + + /* "src/pyscipopt/scip.pxi":2996 + * + * """ + * PY_SCIP_CALL(SCIPaddCons(self._scip, cons.scip_cons)) # <<<<<<<<<<<<<< + * Py_INCREF(cons) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2996, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCons(__pyx_v_self->_scip, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2996, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2996, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2997 + * """ + * PY_SCIP_CALL(SCIPaddCons(self._scip, cons.scip_cons)) + * Py_INCREF(cons) # <<<<<<<<<<<<<< + * + * def addVarSOS1(self, Constraint cons, Variable var, weight): + */ + Py_INCREF(((PyObject *)__pyx_v_cons)); + + /* "src/pyscipopt/scip.pxi":2990 + * return Variable.create(var) + * + * def addPyCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Adds a customly created cons. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.addPyCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":2999 + * Py_INCREF(cons) + * + * def addVarSOS1(self, Constraint cons, Variable var, weight): # <<<<<<<<<<<<<< + * """Add variable to SOS1 constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_305addVarSOS1(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_304addVarSOS1, "Model.addVarSOS1(self, Constraint cons, Variable var, weight)\nAdd variable to SOS1 constraint.\n\n :param Constraint cons: SOS1 constraint\n :param Variable var: new variable\n :param weight: weight of new variable\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_305addVarSOS1 = {"addVarSOS1", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_305addVarSOS1, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_304addVarSOS1}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_305addVarSOS1(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_weight = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addVarSOS1 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_var,&__pyx_n_s_weight,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2999, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2999, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addVarSOS1", 1, 3, 3, 1); __PYX_ERR(0, 2999, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_weight)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 2999, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addVarSOS1", 1, 3, 3, 2); __PYX_ERR(0, 2999, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addVarSOS1") < 0)) __PYX_ERR(0, 2999, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_weight = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addVarSOS1", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 2999, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addVarSOS1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 2999, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 2999, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_304addVarSOS1(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_var, __pyx_v_weight); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_304addVarSOS1(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addVarSOS1", 1); + + /* "src/pyscipopt/scip.pxi":3007 + * + * """ + * PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, cons.scip_cons, var.scip_var, weight)) # <<<<<<<<<<<<<< + * + * def appendVarSOS1(self, Constraint cons, Variable var): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_weight); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3007, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVarSOS1(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":2999 + * Py_INCREF(cons) + * + * def addVarSOS1(self, Constraint cons, Variable var, weight): # <<<<<<<<<<<<<< + * """Add variable to SOS1 constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addVarSOS1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3009 + * PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, cons.scip_cons, var.scip_var, weight)) + * + * def appendVarSOS1(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Append variable to SOS1 constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_307appendVarSOS1(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_306appendVarSOS1, "Model.appendVarSOS1(self, Constraint cons, Variable var)\nAppend variable to SOS1 constraint.\n\n :param Constraint cons: SOS1 constraint\n :param Variable var: variable to append\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_307appendVarSOS1 = {"appendVarSOS1", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_307appendVarSOS1, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_306appendVarSOS1}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_307appendVarSOS1(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("appendVarSOS1 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3009, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3009, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("appendVarSOS1", 1, 2, 2, 1); __PYX_ERR(0, 3009, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "appendVarSOS1") < 0)) __PYX_ERR(0, 3009, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("appendVarSOS1", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3009, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.appendVarSOS1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3009, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3009, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_306appendVarSOS1(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_306appendVarSOS1(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("appendVarSOS1", 1); + + /* "src/pyscipopt/scip.pxi":3016 + * + * """ + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, cons.scip_cons, var.scip_var)) # <<<<<<<<<<<<<< + * + * def addVarSOS2(self, Constraint cons, Variable var, weight): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPappendVarSOS1(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3009 + * PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, cons.scip_cons, var.scip_var, weight)) + * + * def appendVarSOS1(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Append variable to SOS1 constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.appendVarSOS1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3018 + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, cons.scip_cons, var.scip_var)) + * + * def addVarSOS2(self, Constraint cons, Variable var, weight): # <<<<<<<<<<<<<< + * """Add variable to SOS2 constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_309addVarSOS2(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_308addVarSOS2, "Model.addVarSOS2(self, Constraint cons, Variable var, weight)\nAdd variable to SOS2 constraint.\n\n :param Constraint cons: SOS2 constraint\n :param Variable var: new variable\n :param weight: weight of new variable\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_309addVarSOS2 = {"addVarSOS2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_309addVarSOS2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_308addVarSOS2}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_309addVarSOS2(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_weight = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addVarSOS2 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_var,&__pyx_n_s_weight,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3018, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3018, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addVarSOS2", 1, 3, 3, 1); __PYX_ERR(0, 3018, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_weight)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3018, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addVarSOS2", 1, 3, 3, 2); __PYX_ERR(0, 3018, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addVarSOS2") < 0)) __PYX_ERR(0, 3018, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_weight = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addVarSOS2", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3018, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addVarSOS2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3018, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3018, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_308addVarSOS2(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_var, __pyx_v_weight); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_308addVarSOS2(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_weight) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addVarSOS2", 1); + + /* "src/pyscipopt/scip.pxi":3026 + * + * """ + * PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, cons.scip_cons, var.scip_var, weight)) # <<<<<<<<<<<<<< + * + * def appendVarSOS2(self, Constraint cons, Variable var): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3026, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_weight); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3026, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddVarSOS2(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3026, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3026, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3018 + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, cons.scip_cons, var.scip_var)) + * + * def addVarSOS2(self, Constraint cons, Variable var, weight): # <<<<<<<<<<<<<< + * """Add variable to SOS2 constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addVarSOS2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3028 + * PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, cons.scip_cons, var.scip_var, weight)) + * + * def appendVarSOS2(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Append variable to SOS2 constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_311appendVarSOS2(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_310appendVarSOS2, "Model.appendVarSOS2(self, Constraint cons, Variable var)\nAppend variable to SOS2 constraint.\n\n :param Constraint cons: SOS2 constraint\n :param Variable var: variable to append\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_311appendVarSOS2 = {"appendVarSOS2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_311appendVarSOS2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_310appendVarSOS2}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_311appendVarSOS2(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("appendVarSOS2 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3028, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3028, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("appendVarSOS2", 1, 2, 2, 1); __PYX_ERR(0, 3028, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "appendVarSOS2") < 0)) __PYX_ERR(0, 3028, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("appendVarSOS2", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3028, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.appendVarSOS2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3028, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3028, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_310appendVarSOS2(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_310appendVarSOS2(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("appendVarSOS2", 1); + + /* "src/pyscipopt/scip.pxi":3035 + * + * """ + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, cons.scip_cons, var.scip_var)) # <<<<<<<<<<<<<< + * + * def setInitial(self, Constraint cons, newInit): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3035, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPappendVarSOS2(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3035, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3035, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3028 + * PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, cons.scip_cons, var.scip_var, weight)) + * + * def appendVarSOS2(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Append variable to SOS2 constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.appendVarSOS2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3037 + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, cons.scip_cons, var.scip_var)) + * + * def setInitial(self, Constraint cons, newInit): # <<<<<<<<<<<<<< + * """Set "initial" flag of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_313setInitial(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_312setInitial, "Model.setInitial(self, Constraint cons, newInit)\nSet \"initial\" flag of a constraint.\n\n Keyword arguments:\n cons -- constraint\n newInit -- new initial value\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_313setInitial = {"setInitial", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_313setInitial, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_312setInitial}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_313setInitial(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + PyObject *__pyx_v_newInit = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setInitial (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_newInit,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3037, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newInit)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3037, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setInitial", 1, 2, 2, 1); __PYX_ERR(0, 3037, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setInitial") < 0)) __PYX_ERR(0, 3037, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_newInit = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setInitial", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3037, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setInitial", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3037, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_312setInitial(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_newInit); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_312setInitial(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_newInit) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Bool __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setInitial", 1); + + /* "src/pyscipopt/scip.pxi":3044 + * newInit -- new initial value + * """ + * PY_SCIP_CALL(SCIPsetConsInitial(self._scip, cons.scip_cons, newInit)) # <<<<<<<<<<<<<< + * + * def setRemovable(self, Constraint cons, newRem): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_newInit); if (unlikely((__pyx_t_3 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3044, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetConsInitial(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3037 + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, cons.scip_cons, var.scip_var)) + * + * def setInitial(self, Constraint cons, newInit): # <<<<<<<<<<<<<< + * """Set "initial" flag of a constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setInitial", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3046 + * PY_SCIP_CALL(SCIPsetConsInitial(self._scip, cons.scip_cons, newInit)) + * + * def setRemovable(self, Constraint cons, newRem): # <<<<<<<<<<<<<< + * """Set "removable" flag of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_315setRemovable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_314setRemovable, "Model.setRemovable(self, Constraint cons, newRem)\nSet \"removable\" flag of a constraint.\n\n Keyword arguments:\n cons -- constraint\n newRem -- new removable value\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_315setRemovable = {"setRemovable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_315setRemovable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_314setRemovable}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_315setRemovable(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + PyObject *__pyx_v_newRem = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setRemovable (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_newRem,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3046, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newRem)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3046, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setRemovable", 1, 2, 2, 1); __PYX_ERR(0, 3046, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setRemovable") < 0)) __PYX_ERR(0, 3046, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_newRem = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setRemovable", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3046, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setRemovable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3046, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_314setRemovable(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_newRem); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_314setRemovable(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_newRem) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Bool __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setRemovable", 1); + + /* "src/pyscipopt/scip.pxi":3053 + * newRem -- new removable value + * """ + * PY_SCIP_CALL(SCIPsetConsRemovable(self._scip, cons.scip_cons, newRem)) # <<<<<<<<<<<<<< + * + * def setEnforced(self, Constraint cons, newEnf): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3053, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_newRem); if (unlikely((__pyx_t_3 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3053, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetConsRemovable(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3053, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3053, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3046 + * PY_SCIP_CALL(SCIPsetConsInitial(self._scip, cons.scip_cons, newInit)) + * + * def setRemovable(self, Constraint cons, newRem): # <<<<<<<<<<<<<< + * """Set "removable" flag of a constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setRemovable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3055 + * PY_SCIP_CALL(SCIPsetConsRemovable(self._scip, cons.scip_cons, newRem)) + * + * def setEnforced(self, Constraint cons, newEnf): # <<<<<<<<<<<<<< + * """Set "enforced" flag of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_317setEnforced(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_316setEnforced, "Model.setEnforced(self, Constraint cons, newEnf)\nSet \"enforced\" flag of a constraint.\n\n Keyword arguments:\n cons -- constraint\n newEnf -- new enforced value\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_317setEnforced = {"setEnforced", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_317setEnforced, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_316setEnforced}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_317setEnforced(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + PyObject *__pyx_v_newEnf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setEnforced (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_newEnf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3055, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newEnf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3055, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setEnforced", 1, 2, 2, 1); __PYX_ERR(0, 3055, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setEnforced") < 0)) __PYX_ERR(0, 3055, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_newEnf = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setEnforced", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3055, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setEnforced", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3055, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_316setEnforced(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_newEnf); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_316setEnforced(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_newEnf) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Bool __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setEnforced", 1); + + /* "src/pyscipopt/scip.pxi":3062 + * newEnf -- new enforced value + * """ + * PY_SCIP_CALL(SCIPsetConsEnforced(self._scip, cons.scip_cons, newEnf)) # <<<<<<<<<<<<<< + * + * def setCheck(self, Constraint cons, newCheck): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_newEnf); if (unlikely((__pyx_t_3 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3062, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetConsEnforced(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3055 + * PY_SCIP_CALL(SCIPsetConsRemovable(self._scip, cons.scip_cons, newRem)) + * + * def setEnforced(self, Constraint cons, newEnf): # <<<<<<<<<<<<<< + * """Set "enforced" flag of a constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setEnforced", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3064 + * PY_SCIP_CALL(SCIPsetConsEnforced(self._scip, cons.scip_cons, newEnf)) + * + * def setCheck(self, Constraint cons, newCheck): # <<<<<<<<<<<<<< + * """Set "check" flag of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_319setCheck(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_318setCheck, "Model.setCheck(self, Constraint cons, newCheck)\nSet \"check\" flag of a constraint.\n\n Keyword arguments:\n cons -- constraint\n newCheck -- new check value\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_319setCheck = {"setCheck", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_319setCheck, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_318setCheck}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_319setCheck(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + PyObject *__pyx_v_newCheck = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setCheck (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_newCheck,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3064, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newCheck)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3064, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setCheck", 1, 2, 2, 1); __PYX_ERR(0, 3064, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setCheck") < 0)) __PYX_ERR(0, 3064, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_newCheck = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setCheck", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3064, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setCheck", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3064, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_318setCheck(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_newCheck); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_318setCheck(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_newCheck) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Bool __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setCheck", 1); + + /* "src/pyscipopt/scip.pxi":3071 + * newCheck -- new check value + * """ + * PY_SCIP_CALL(SCIPsetConsChecked(self._scip, cons.scip_cons, newCheck)) # <<<<<<<<<<<<<< + * + * def chgRhs(self, Constraint cons, rhs): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3071, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_newCheck); if (unlikely((__pyx_t_3 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3071, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetConsChecked(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3071, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3071, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3064 + * PY_SCIP_CALL(SCIPsetConsEnforced(self._scip, cons.scip_cons, newEnf)) + * + * def setCheck(self, Constraint cons, newCheck): # <<<<<<<<<<<<<< + * """Set "check" flag of a constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setCheck", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3073 + * PY_SCIP_CALL(SCIPsetConsChecked(self._scip, cons.scip_cons, newCheck)) + * + * def chgRhs(self, Constraint cons, rhs): # <<<<<<<<<<<<<< + * """Change right hand side value of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_321chgRhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_320chgRhs, "Model.chgRhs(self, Constraint cons, rhs)\nChange right hand side value of a constraint.\n\n :param Constraint cons: linear or quadratic constraint\n :param rhs: new right hand side (set to None for +infinity)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_321chgRhs = {"chgRhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_321chgRhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_320chgRhs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_321chgRhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + PyObject *__pyx_v_rhs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgRhs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_rhs,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3073, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_rhs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3073, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgRhs", 1, 2, 2, 1); __PYX_ERR(0, 3073, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgRhs") < 0)) __PYX_ERR(0, 3073, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_rhs = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgRhs", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3073, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgRhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3073, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_320chgRhs(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_rhs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_320chgRhs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_rhs) { + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgRhs", 0); + __Pyx_INCREF(__pyx_v_rhs); + + /* "src/pyscipopt/scip.pxi":3081 + * """ + * + * if rhs is None: # <<<<<<<<<<<<<< + * rhs = SCIPinfinity(self._scip) + * + */ + __pyx_t_1 = (__pyx_v_rhs == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3082 + * + * if rhs is None: + * rhs = SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + */ + __pyx_t_2 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3082, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_rhs, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3081 + * """ + * + * if rhs is None: # <<<<<<<<<<<<<< + * rhs = SCIPinfinity(self._scip) + * + */ + } + + /* "src/pyscipopt/scip.pxi":3084 + * rhs = SCIPinfinity(self._scip) + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if constype == 'linear': + * PY_SCIP_CALL(SCIPchgRhsLinear(self._scip, cons.scip_cons, rhs)) + */ + __pyx_t_2 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3084, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3084, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_decode_bytes(__pyx_t_3, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3084, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_constype = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3085 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgRhsLinear(self._scip, cons.scip_cons, rhs)) + * elif constype == 'nonlinear': + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3085, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3086 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': + * PY_SCIP_CALL(SCIPchgRhsLinear(self._scip, cons.scip_cons, rhs)) # <<<<<<<<<<<<<< + * elif constype == 'nonlinear': + * PY_SCIP_CALL(SCIPchgRhsNonlinear(self._scip, cons.scip_cons, rhs)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_rhs); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3086, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgRhsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3085 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgRhsLinear(self._scip, cons.scip_cons, rhs)) + * elif constype == 'nonlinear': + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3087 + * if constype == 'linear': + * PY_SCIP_CALL(SCIPchgRhsLinear(self._scip, cons.scip_cons, rhs)) + * elif constype == 'nonlinear': # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgRhsNonlinear(self._scip, cons.scip_cons, rhs)) + * else: + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_nonlinear, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3087, __pyx_L1_error) + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":3088 + * PY_SCIP_CALL(SCIPchgRhsLinear(self._scip, cons.scip_cons, rhs)) + * elif constype == 'nonlinear': + * PY_SCIP_CALL(SCIPchgRhsNonlinear(self._scip, cons.scip_cons, rhs)) # <<<<<<<<<<<<<< + * else: + * raise Warning("method cannot be called for constraints of type " + constype) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_rhs); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3088, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgRhsNonlinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3087 + * if constype == 'linear': + * PY_SCIP_CALL(SCIPchgRhsLinear(self._scip, cons.scip_cons, rhs)) + * elif constype == 'nonlinear': # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgRhsNonlinear(self._scip, cons.scip_cons, rhs)) + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3090 + * PY_SCIP_CALL(SCIPchgRhsNonlinear(self._scip, cons.scip_cons, rhs)) + * else: + * raise Warning("method cannot be called for constraints of type " + constype) # <<<<<<<<<<<<<< + * + * def chgLhs(self, Constraint cons, lhs): + */ + /*else*/ { + __pyx_t_2 = PyNumber_Add(__pyx_kp_u_method_cannot_be_called_for_cons, __pyx_v_constype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 3090, __pyx_L1_error) + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3073 + * PY_SCIP_CALL(SCIPsetConsChecked(self._scip, cons.scip_cons, newCheck)) + * + * def chgRhs(self, Constraint cons, rhs): # <<<<<<<<<<<<<< + * """Change right hand side value of a constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgRhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3092 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def chgLhs(self, Constraint cons, lhs): # <<<<<<<<<<<<<< + * """Change left hand side value of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_323chgLhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_322chgLhs, "Model.chgLhs(self, Constraint cons, lhs)\nChange left hand side value of a constraint.\n\n :param Constraint cons: linear or quadratic constraint\n :param lhs: new left hand side (set to None for -infinity)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_323chgLhs = {"chgLhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_323chgLhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_322chgLhs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_323chgLhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + PyObject *__pyx_v_lhs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgLhs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_lhs,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3092, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lhs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3092, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgLhs", 1, 2, 2, 1); __PYX_ERR(0, 3092, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgLhs") < 0)) __PYX_ERR(0, 3092, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_lhs = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgLhs", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3092, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgLhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3092, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_322chgLhs(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_lhs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_322chgLhs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_lhs) { + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgLhs", 0); + __Pyx_INCREF(__pyx_v_lhs); + + /* "src/pyscipopt/scip.pxi":3100 + * """ + * + * if lhs is None: # <<<<<<<<<<<<<< + * lhs = -SCIPinfinity(self._scip) + * + */ + __pyx_t_1 = (__pyx_v_lhs == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3101 + * + * if lhs is None: + * lhs = -SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + */ + __pyx_t_2 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_lhs, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3100 + * """ + * + * if lhs is None: # <<<<<<<<<<<<<< + * lhs = -SCIPinfinity(self._scip) + * + */ + } + + /* "src/pyscipopt/scip.pxi":3103 + * lhs = -SCIPinfinity(self._scip) + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if constype == 'linear': + * PY_SCIP_CALL(SCIPchgLhsLinear(self._scip, cons.scip_cons, lhs)) + */ + __pyx_t_2 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_decode_bytes(__pyx_t_3, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_constype = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3104 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgLhsLinear(self._scip, cons.scip_cons, lhs)) + * elif constype == 'nonlinear': + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3104, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3105 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': + * PY_SCIP_CALL(SCIPchgLhsLinear(self._scip, cons.scip_cons, lhs)) # <<<<<<<<<<<<<< + * elif constype == 'nonlinear': + * PY_SCIP_CALL(SCIPchgLhsNonlinear(self._scip, cons.scip_cons, lhs)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_lhs); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3105, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgLhsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3104 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgLhsLinear(self._scip, cons.scip_cons, lhs)) + * elif constype == 'nonlinear': + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3106 + * if constype == 'linear': + * PY_SCIP_CALL(SCIPchgLhsLinear(self._scip, cons.scip_cons, lhs)) + * elif constype == 'nonlinear': # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgLhsNonlinear(self._scip, cons.scip_cons, lhs)) + * else: + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_nonlinear, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3106, __pyx_L1_error) + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":3107 + * PY_SCIP_CALL(SCIPchgLhsLinear(self._scip, cons.scip_cons, lhs)) + * elif constype == 'nonlinear': + * PY_SCIP_CALL(SCIPchgLhsNonlinear(self._scip, cons.scip_cons, lhs)) # <<<<<<<<<<<<<< + * else: + * raise Warning("method cannot be called for constraints of type " + constype) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_lhs); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3107, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgLhsNonlinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3106 + * if constype == 'linear': + * PY_SCIP_CALL(SCIPchgLhsLinear(self._scip, cons.scip_cons, lhs)) + * elif constype == 'nonlinear': # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgLhsNonlinear(self._scip, cons.scip_cons, lhs)) + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3109 + * PY_SCIP_CALL(SCIPchgLhsNonlinear(self._scip, cons.scip_cons, lhs)) + * else: + * raise Warning("method cannot be called for constraints of type " + constype) # <<<<<<<<<<<<<< + * + * def getRhs(self, Constraint cons): + */ + /*else*/ { + __pyx_t_2 = PyNumber_Add(__pyx_kp_u_method_cannot_be_called_for_cons, __pyx_v_constype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 3109, __pyx_L1_error) + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3092 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def chgLhs(self, Constraint cons, lhs): # <<<<<<<<<<<<<< + * """Change left hand side value of a constraint. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgLhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XDECREF(__pyx_v_lhs); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3111 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def getRhs(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve right hand side value of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_325getRhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_324getRhs, "Model.getRhs(self, Constraint cons)\nRetrieve right hand side value of a constraint.\n\n :param Constraint cons: linear or quadratic constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_325getRhs = {"getRhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_325getRhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_324getRhs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_325getRhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRhs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3111, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getRhs") < 0)) __PYX_ERR(0, 3111, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getRhs", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3111, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getRhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3111, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_324getRhs(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_324getRhs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRhs", 1); + + /* "src/pyscipopt/scip.pxi":3117 + * + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if constype == 'linear': + * return SCIPgetRhsLinear(self._scip, cons.scip_cons) + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3118 + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * return SCIPgetRhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3118, __pyx_L1_error) + if (__pyx_t_3) { + + /* "src/pyscipopt/scip.pxi":3119 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': + * return SCIPgetRhsLinear(self._scip, cons.scip_cons) # <<<<<<<<<<<<<< + * elif constype == 'quadratic': + * return SCIPgetRhsNonlinear(cons.scip_cons) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetRhsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3118 + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * return SCIPgetRhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': + */ + } + + /* "src/pyscipopt/scip.pxi":3120 + * if constype == 'linear': + * return SCIPgetRhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': # <<<<<<<<<<<<<< + * return SCIPgetRhsNonlinear(cons.scip_cons) + * else: + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_quadratic, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3120, __pyx_L1_error) + if (likely(__pyx_t_3)) { + + /* "src/pyscipopt/scip.pxi":3121 + * return SCIPgetRhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': + * return SCIPgetRhsNonlinear(cons.scip_cons) # <<<<<<<<<<<<<< + * else: + * raise Warning("method cannot be called for constraints of type " + constype) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetRhsNonlinear(__pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3120 + * if constype == 'linear': + * return SCIPgetRhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': # <<<<<<<<<<<<<< + * return SCIPgetRhsNonlinear(cons.scip_cons) + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":3123 + * return SCIPgetRhsNonlinear(cons.scip_cons) + * else: + * raise Warning("method cannot be called for constraints of type " + constype) # <<<<<<<<<<<<<< + * + * def getLhs(self, Constraint cons): + */ + /*else*/ { + __pyx_t_1 = PyNumber_Add(__pyx_kp_u_method_cannot_be_called_for_cons, __pyx_v_constype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 3123, __pyx_L1_error) + } + + /* "src/pyscipopt/scip.pxi":3111 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def getRhs(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve right hand side value of a constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getRhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3125 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def getLhs(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve left hand side value of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_327getLhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_326getLhs, "Model.getLhs(self, Constraint cons)\nRetrieve left hand side value of a constraint.\n\n :param Constraint cons: linear or quadratic constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_327getLhs = {"getLhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_327getLhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_326getLhs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_327getLhs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLhs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3125, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getLhs") < 0)) __PYX_ERR(0, 3125, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getLhs", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3125, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getLhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3125, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_326getLhs(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_326getLhs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLhs", 1); + + /* "src/pyscipopt/scip.pxi":3131 + * + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if constype == 'linear': + * return SCIPgetLhsLinear(self._scip, cons.scip_cons) + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3132 + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * return SCIPgetLhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3132, __pyx_L1_error) + if (__pyx_t_3) { + + /* "src/pyscipopt/scip.pxi":3133 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': + * return SCIPgetLhsLinear(self._scip, cons.scip_cons) # <<<<<<<<<<<<<< + * elif constype == 'quadratic': + * return SCIPgetLhsNonlinear(cons.scip_cons) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetLhsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3132 + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * return SCIPgetLhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': + */ + } + + /* "src/pyscipopt/scip.pxi":3134 + * if constype == 'linear': + * return SCIPgetLhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': # <<<<<<<<<<<<<< + * return SCIPgetLhsNonlinear(cons.scip_cons) + * else: + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_quadratic, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3134, __pyx_L1_error) + if (likely(__pyx_t_3)) { + + /* "src/pyscipopt/scip.pxi":3135 + * return SCIPgetLhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': + * return SCIPgetLhsNonlinear(cons.scip_cons) # <<<<<<<<<<<<<< + * else: + * raise Warning("method cannot be called for constraints of type " + constype) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetLhsNonlinear(__pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3134 + * if constype == 'linear': + * return SCIPgetLhsLinear(self._scip, cons.scip_cons) + * elif constype == 'quadratic': # <<<<<<<<<<<<<< + * return SCIPgetLhsNonlinear(cons.scip_cons) + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":3137 + * return SCIPgetLhsNonlinear(cons.scip_cons) + * else: + * raise Warning("method cannot be called for constraints of type " + constype) # <<<<<<<<<<<<<< + * + * def chgCoefLinear(self, Constraint cons, Variable var, value): + */ + /*else*/ { + __pyx_t_1 = PyNumber_Add(__pyx_kp_u_method_cannot_be_called_for_cons, __pyx_v_constype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 3137, __pyx_L1_error) + } + + /* "src/pyscipopt/scip.pxi":3125 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def getLhs(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve left hand side value of a constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLhs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3139 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def chgCoefLinear(self, Constraint cons, Variable var, value): # <<<<<<<<<<<<<< + * """Changes coefficient of variable in linear constraint; + * deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_329chgCoefLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_328chgCoefLinear, "Model.chgCoefLinear(self, Constraint cons, Variable var, value)\nChanges coefficient of variable in linear constraint;\n deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint\n This method may only be called during problem creation stage for an original constraint and variable.\n This method requires linear time to search for occurences of the variable in the constraint data.\n\n :param Constraint cons: linear constraint\n :param Variable var: variable of constraint entry\n :param value: new coefficient of constraint entry\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_329chgCoefLinear = {"chgCoefLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_329chgCoefLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_328chgCoefLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_329chgCoefLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgCoefLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_var,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3139, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3139, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgCoefLinear", 1, 3, 3, 1); __PYX_ERR(0, 3139, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3139, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgCoefLinear", 1, 3, 3, 2); __PYX_ERR(0, 3139, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgCoefLinear") < 0)) __PYX_ERR(0, 3139, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_value = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgCoefLinear", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3139, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgCoefLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3139, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3139, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_328chgCoefLinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_var, __pyx_v_value); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_328chgCoefLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgCoefLinear", 1); + + /* "src/pyscipopt/scip.pxi":3150 + * + * """ + * PY_SCIP_CALL( SCIPchgCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) ) # <<<<<<<<<<<<<< + * + * def delCoefLinear(self, Constraint cons, Variable var): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3150, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgCoefLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3139 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def chgCoefLinear(self, Constraint cons, Variable var, value): # <<<<<<<<<<<<<< + * """Changes coefficient of variable in linear constraint; + * deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgCoefLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3152 + * PY_SCIP_CALL( SCIPchgCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) ) + * + * def delCoefLinear(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Deletes variable from linear constraint + * This method may only be called during problem creation stage for an original constraint and variable. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_331delCoefLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_330delCoefLinear, "Model.delCoefLinear(self, Constraint cons, Variable var)\nDeletes variable from linear constraint\n This method may only be called during problem creation stage for an original constraint and variable.\n This method requires linear time to search for occurences of the variable in the constraint data.\n\n :param Constraint cons: linear constraint\n :param Variable var: variable of constraint entry\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_331delCoefLinear = {"delCoefLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_331delCoefLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_330delCoefLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_331delCoefLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("delCoefLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3152, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3152, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("delCoefLinear", 1, 2, 2, 1); __PYX_ERR(0, 3152, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delCoefLinear") < 0)) __PYX_ERR(0, 3152, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delCoefLinear", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3152, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.delCoefLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3152, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3152, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_330delCoefLinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_330delCoefLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("delCoefLinear", 1); + + /* "src/pyscipopt/scip.pxi":3162 + * """ + * + * PY_SCIP_CALL( SCIPdelCoefLinear(self._scip, cons.scip_cons, var.scip_var) ) # <<<<<<<<<<<<<< + * + * def addCoefLinear(self, Constraint cons, Variable var, value): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPdelCoefLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3162, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3152 + * PY_SCIP_CALL( SCIPchgCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) ) + * + * def delCoefLinear(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Deletes variable from linear constraint + * This method may only be called during problem creation stage for an original constraint and variable. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.delCoefLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3164 + * PY_SCIP_CALL( SCIPdelCoefLinear(self._scip, cons.scip_cons, var.scip_var) ) + * + * def addCoefLinear(self, Constraint cons, Variable var, value): # <<<<<<<<<<<<<< + * """Adds coefficient to linear constraint (if it is not zero) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_333addCoefLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_332addCoefLinear, "Model.addCoefLinear(self, Constraint cons, Variable var, value)\nAdds coefficient to linear constraint (if it is not zero)\n\n :param Constraint cons: linear constraint\n :param Variable var: variable of constraint entry\n :param value: coefficient of constraint entry\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_333addCoefLinear = {"addCoefLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_333addCoefLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_332addCoefLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_333addCoefLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addCoefLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_var,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3164, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3164, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addCoefLinear", 1, 3, 3, 1); __PYX_ERR(0, 3164, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3164, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addCoefLinear", 1, 3, 3, 2); __PYX_ERR(0, 3164, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addCoefLinear") < 0)) __PYX_ERR(0, 3164, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_value = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addCoefLinear", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3164, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addCoefLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3164, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3164, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_332addCoefLinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_var, __pyx_v_value); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_332addCoefLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addCoefLinear", 1); + + /* "src/pyscipopt/scip.pxi":3173 + * """ + * + * PY_SCIP_CALL( SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) ) # <<<<<<<<<<<<<< + * + * def getActivity(self, Constraint cons, Solution sol = None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3173, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddCoefLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3164 + * PY_SCIP_CALL( SCIPdelCoefLinear(self._scip, cons.scip_cons, var.scip_var) ) + * + * def addCoefLinear(self, Constraint cons, Variable var, value): # <<<<<<<<<<<<<< + * """Adds coefficient to linear constraint (if it is not zero) + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addCoefLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3175 + * PY_SCIP_CALL( SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) ) + * + * def getActivity(self, Constraint cons, Solution sol = None): # <<<<<<<<<<<<<< + * """Retrieve activity of given constraint. + * Can only be called after solving is completed. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_335getActivity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_334getActivity, "Model.getActivity(self, Constraint cons, Solution sol=None)\nRetrieve activity of given constraint.\n Can only be called after solving is completed.\n\n :param Constraint cons: linear or quadratic constraint\n :param Solution sol: solution to compute activity of, None to use current node's solution (Default value = None)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_335getActivity = {"getActivity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_335getActivity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_334getActivity}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_335getActivity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getActivity (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_sol,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3175, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3175, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getActivity") < 0)) __PYX_ERR(0, 3175, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getActivity", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3175, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getActivity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3175, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 3175, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_334getActivity(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_sol); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_334getActivity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol) { + SCIP_Real __pyx_v_activity; + SCIP_SOL *__pyx_v_scip_sol; + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + SCIP_SOL *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getActivity", 1); + + /* "src/pyscipopt/scip.pxi":3186 + * cdef SCIP_SOL* scip_sol + * + * if not self.getStage() >= SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning("method cannot be called before problem is solved") + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_SOLVING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3186, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3186, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = (!__pyx_t_5); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":3187 + * + * if not self.getStage() >= SCIP_STAGE_SOLVING: + * raise Warning("method cannot be called before problem is solved") # <<<<<<<<<<<<<< + * + * if isinstance(sol, Solution): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 3187, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3186 + * cdef SCIP_SOL* scip_sol + * + * if not self.getStage() >= SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning("method cannot be called before problem is solved") + * + */ + } + + /* "src/pyscipopt/scip.pxi":3189 + * raise Warning("method cannot be called before problem is solved") + * + * if isinstance(sol, Solution): # <<<<<<<<<<<<<< + * scip_sol = sol.sol + * else: + */ + __pyx_t_6 = __Pyx_TypeCheck(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":3190 + * + * if isinstance(sol, Solution): + * scip_sol = sol.sol # <<<<<<<<<<<<<< + * else: + * scip_sol = NULL + */ + __pyx_t_7 = __pyx_v_sol->sol; + __pyx_v_scip_sol = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":3189 + * raise Warning("method cannot be called before problem is solved") + * + * if isinstance(sol, Solution): # <<<<<<<<<<<<<< + * scip_sol = sol.sol + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3192 + * scip_sol = sol.sol + * else: + * scip_sol = NULL # <<<<<<<<<<<<<< + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + */ + /*else*/ { + __pyx_v_scip_sol = NULL; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3194 + * scip_sol = NULL + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if constype == 'linear': + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) + */ + __pyx_t_3 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3195 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) + * else: + */ + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3195, __pyx_L1_error) + if (likely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":3196 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) # <<<<<<<<<<<<<< + * else: + * raise Warning("method cannot be called for constraints of type " + constype) + */ + __pyx_v_activity = SCIPgetActivityLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_scip_sol); + + /* "src/pyscipopt/scip.pxi":3195 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) + * else: + */ + goto __pyx_L5; + } + + /* "src/pyscipopt/scip.pxi":3198 + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) + * else: + * raise Warning("method cannot be called for constraints of type " + constype) # <<<<<<<<<<<<<< + * + * return activity + */ + /*else*/ { + __pyx_t_3 = PyNumber_Add(__pyx_kp_u_method_cannot_be_called_for_cons, __pyx_v_constype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 3198, __pyx_L1_error) + } + __pyx_L5:; + + /* "src/pyscipopt/scip.pxi":3200 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * return activity # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_activity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3175 + * PY_SCIP_CALL( SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) ) + * + * def getActivity(self, Constraint cons, Solution sol = None): # <<<<<<<<<<<<<< + * """Retrieve activity of given constraint. + * Can only be called after solving is completed. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.getActivity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3203 + * + * + * def getSlack(self, Constraint cons, Solution sol = None, side = None): # <<<<<<<<<<<<<< + * """Retrieve slack of given constraint. + * Can only be called after solving is completed. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_337getSlack(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_336getSlack, "Model.getSlack(self, Constraint cons, Solution sol=None, side=None)\nRetrieve slack of given constraint.\n Can only be called after solving is completed.\n\n\n :param Constraint cons: linear or quadratic constraint\n :param Solution sol: solution to compute slack of, None to use current node's solution (Default value = None)\n :param side: whether to use 'lhs' or 'rhs' for ranged constraints, None to return minimum (Default value = None)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_337getSlack = {"getSlack", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_337getSlack, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_336getSlack}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_337getSlack(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + PyObject *__pyx_v_side = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getSlack (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_sol,&__pyx_n_s_side,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3203, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3203, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_side); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3203, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getSlack") < 0)) __PYX_ERR(0, 3203, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[1]); + __pyx_v_side = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getSlack", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 3203, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getSlack", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3203, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 3203, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_336getSlack(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_sol, __pyx_v_side); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_336getSlack(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol, PyObject *__pyx_v_side) { + SCIP_Real __pyx_v_activity; + SCIP_SOL *__pyx_v_scip_sol; + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_v_lhs = NULL; + PyObject *__pyx_v_rhs = NULL; + PyObject *__pyx_v_lhsslack = NULL; + PyObject *__pyx_v_rhsslack = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + SCIP_SOL *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getSlack", 1); + + /* "src/pyscipopt/scip.pxi":3217 + * + * + * if not self.getStage() >= SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning("method cannot be called before problem is solved") + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_SOLVING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3217, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3217, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = (!__pyx_t_5); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":3218 + * + * if not self.getStage() >= SCIP_STAGE_SOLVING: + * raise Warning("method cannot be called before problem is solved") # <<<<<<<<<<<<<< + * + * if isinstance(sol, Solution): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 3218, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3217 + * + * + * if not self.getStage() >= SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning("method cannot be called before problem is solved") + * + */ + } + + /* "src/pyscipopt/scip.pxi":3220 + * raise Warning("method cannot be called before problem is solved") + * + * if isinstance(sol, Solution): # <<<<<<<<<<<<<< + * scip_sol = sol.sol + * else: + */ + __pyx_t_6 = __Pyx_TypeCheck(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":3221 + * + * if isinstance(sol, Solution): + * scip_sol = sol.sol # <<<<<<<<<<<<<< + * else: + * scip_sol = NULL + */ + __pyx_t_7 = __pyx_v_sol->sol; + __pyx_v_scip_sol = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":3220 + * raise Warning("method cannot be called before problem is solved") + * + * if isinstance(sol, Solution): # <<<<<<<<<<<<<< + * scip_sol = sol.sol + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3223 + * scip_sol = sol.sol + * else: + * scip_sol = NULL # <<<<<<<<<<<<<< + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + */ + /*else*/ { + __pyx_v_scip_sol = NULL; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3225 + * scip_sol = NULL + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if constype == 'linear': + * lhs = SCIPgetLhsLinear(self._scip, cons.scip_cons) + */ + __pyx_t_3 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3226 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * lhs = SCIPgetLhsLinear(self._scip, cons.scip_cons) + * rhs = SCIPgetRhsLinear(self._scip, cons.scip_cons) + */ + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3226, __pyx_L1_error) + if (likely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":3227 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': + * lhs = SCIPgetLhsLinear(self._scip, cons.scip_cons) # <<<<<<<<<<<<<< + * rhs = SCIPgetRhsLinear(self._scip, cons.scip_cons) + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) + */ + __pyx_t_3 = PyFloat_FromDouble(SCIPgetLhsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_lhs = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3228 + * if constype == 'linear': + * lhs = SCIPgetLhsLinear(self._scip, cons.scip_cons) + * rhs = SCIPgetRhsLinear(self._scip, cons.scip_cons) # <<<<<<<<<<<<<< + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) + * else: + */ + __pyx_t_3 = PyFloat_FromDouble(SCIPgetRhsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3229 + * lhs = SCIPgetLhsLinear(self._scip, cons.scip_cons) + * rhs = SCIPgetRhsLinear(self._scip, cons.scip_cons) + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) # <<<<<<<<<<<<<< + * else: + * raise Warning("method cannot be called for constraints of type " + constype) + */ + __pyx_v_activity = SCIPgetActivityLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, __pyx_v_scip_sol); + + /* "src/pyscipopt/scip.pxi":3226 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if constype == 'linear': # <<<<<<<<<<<<<< + * lhs = SCIPgetLhsLinear(self._scip, cons.scip_cons) + * rhs = SCIPgetRhsLinear(self._scip, cons.scip_cons) + */ + goto __pyx_L5; + } + + /* "src/pyscipopt/scip.pxi":3231 + * activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol) + * else: + * raise Warning("method cannot be called for constraints of type " + constype) # <<<<<<<<<<<<<< + * + * lhsslack = activity - lhs + */ + /*else*/ { + __pyx_t_3 = PyNumber_Add(__pyx_kp_u_method_cannot_be_called_for_cons, __pyx_v_constype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 3231, __pyx_L1_error) + } + __pyx_L5:; + + /* "src/pyscipopt/scip.pxi":3233 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * lhsslack = activity - lhs # <<<<<<<<<<<<<< + * rhsslack = rhs - activity + * + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_activity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Subtract(__pyx_t_2, __pyx_v_lhs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_lhsslack = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3234 + * + * lhsslack = activity - lhs + * rhsslack = rhs - activity # <<<<<<<<<<<<<< + * + * if side == 'lhs': + */ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_activity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyNumber_Subtract(__pyx_v_rhs, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_rhsslack = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3236 + * rhsslack = rhs - activity + * + * if side == 'lhs': # <<<<<<<<<<<<<< + * return lhsslack + * elif side == 'rhs': + */ + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_v_side, __pyx_n_u_lhs, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3236, __pyx_L1_error) + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":3237 + * + * if side == 'lhs': + * return lhsslack # <<<<<<<<<<<<<< + * elif side == 'rhs': + * return rhsslack + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_lhsslack); + __pyx_r = __pyx_v_lhsslack; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3236 + * rhsslack = rhs - activity + * + * if side == 'lhs': # <<<<<<<<<<<<<< + * return lhsslack + * elif side == 'rhs': + */ + } + + /* "src/pyscipopt/scip.pxi":3238 + * if side == 'lhs': + * return lhsslack + * elif side == 'rhs': # <<<<<<<<<<<<<< + * return rhsslack + * else: + */ + __pyx_t_6 = (__Pyx_PyUnicode_Equals(__pyx_v_side, __pyx_n_u_rhs, Py_EQ)); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3238, __pyx_L1_error) + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":3239 + * return lhsslack + * elif side == 'rhs': + * return rhsslack # <<<<<<<<<<<<<< + * else: + * return min(lhsslack, rhsslack) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_rhsslack); + __pyx_r = __pyx_v_rhsslack; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3238 + * if side == 'lhs': + * return lhsslack + * elif side == 'rhs': # <<<<<<<<<<<<<< + * return rhsslack + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":3241 + * return rhsslack + * else: + * return min(lhsslack, rhsslack) # <<<<<<<<<<<<<< + * + * def getTransformedCons(self, Constraint cons): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_rhsslack); + __pyx_t_2 = __pyx_v_rhsslack; + __Pyx_INCREF(__pyx_v_lhsslack); + __pyx_t_3 = __pyx_v_lhsslack; + __pyx_t_8 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3241, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 3241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_6) { + __Pyx_INCREF(__pyx_t_2); + __pyx_t_1 = __pyx_t_2; + } else { + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_INCREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":3203 + * + * + * def getSlack(self, Constraint cons, Solution sol = None, side = None): # <<<<<<<<<<<<<< + * """Retrieve slack of given constraint. + * Can only be called after solving is completed. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.getSlack", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XDECREF(__pyx_v_lhs); + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XDECREF(__pyx_v_lhsslack); + __Pyx_XDECREF(__pyx_v_rhsslack); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3243 + * return min(lhsslack, rhsslack) + * + * def getTransformedCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve transformed constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_339getTransformedCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_338getTransformedCons, "Model.getTransformedCons(self, Constraint cons)\nRetrieve transformed constraint.\n\n :param Constraint cons: constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_339getTransformedCons = {"getTransformedCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_339getTransformedCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_338getTransformedCons}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_339getTransformedCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getTransformedCons (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3243, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getTransformedCons") < 0)) __PYX_ERR(0, 3243, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getTransformedCons", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3243, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getTransformedCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3243, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_338getTransformedCons(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_338getTransformedCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + SCIP_CONS *__pyx_v_transcons; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getTransformedCons", 1); + + /* "src/pyscipopt/scip.pxi":3250 + * """ + * cdef SCIP_CONS* transcons + * PY_SCIP_CALL(SCIPgetTransformedCons(self._scip, cons.scip_cons, &transcons)) # <<<<<<<<<<<<<< + * return Constraint.create(transcons) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetTransformedCons(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, (&__pyx_v_transcons))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3251 + * cdef SCIP_CONS* transcons + * PY_SCIP_CALL(SCIPgetTransformedCons(self._scip, cons.scip_cons, &transcons)) + * return Constraint.create(transcons) # <<<<<<<<<<<<<< + * + * def isNLPConstructed(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_10Constraint_create(__pyx_v_transcons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3243 + * return min(lhsslack, rhsslack) + * + * def getTransformedCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve transformed constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getTransformedCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3253 + * return Constraint.create(transcons) + * + * def isNLPConstructed(self): # <<<<<<<<<<<<<< + * """returns whether SCIP's internal NLP has been constructed""" + * return SCIPisNLPConstructed(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_341isNLPConstructed(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_340isNLPConstructed, "Model.isNLPConstructed(self)\nreturns whether SCIP's internal NLP has been constructed"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_341isNLPConstructed = {"isNLPConstructed", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_341isNLPConstructed, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_340isNLPConstructed}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_341isNLPConstructed(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isNLPConstructed (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isNLPConstructed", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isNLPConstructed", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_340isNLPConstructed(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_340isNLPConstructed(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isNLPConstructed", 1); + + /* "src/pyscipopt/scip.pxi":3255 + * def isNLPConstructed(self): + * """returns whether SCIP's internal NLP has been constructed""" + * return SCIPisNLPConstructed(self._scip) # <<<<<<<<<<<<<< + * + * def getNNlRows(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPisNLPConstructed(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3253 + * return Constraint.create(transcons) + * + * def isNLPConstructed(self): # <<<<<<<<<<<<<< + * """returns whether SCIP's internal NLP has been constructed""" + * return SCIPisNLPConstructed(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.isNLPConstructed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3257 + * return SCIPisNLPConstructed(self._scip) + * + * def getNNlRows(self): # <<<<<<<<<<<<<< + * """gets current number of nonlinear rows in SCIP's internal NLP""" + * return SCIPgetNNLPNlRows(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_343getNNlRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_342getNNlRows, "Model.getNNlRows(self)\ngets current number of nonlinear rows in SCIP's internal NLP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_343getNNlRows = {"getNNlRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_343getNNlRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_342getNNlRows}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_343getNNlRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNNlRows (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNNlRows", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNNlRows", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_342getNNlRows(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_342getNNlRows(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNNlRows", 1); + + /* "src/pyscipopt/scip.pxi":3259 + * def getNNlRows(self): + * """gets current number of nonlinear rows in SCIP's internal NLP""" + * return SCIPgetNNLPNlRows(self._scip) # <<<<<<<<<<<<<< + * + * def getNlRows(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNNLPNlRows(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3257 + * return SCIPisNLPConstructed(self._scip) + * + * def getNNlRows(self): # <<<<<<<<<<<<<< + * """gets current number of nonlinear rows in SCIP's internal NLP""" + * return SCIPgetNNLPNlRows(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNNlRows", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3261 + * return SCIPgetNNLPNlRows(self._scip) + * + * def getNlRows(self): # <<<<<<<<<<<<<< + * """returns a list with the nonlinear rows in SCIP's internal NLP""" + * cdef SCIP_NLROW** nlrows + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_345getNlRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_344getNlRows, "Model.getNlRows(self)\nreturns a list with the nonlinear rows in SCIP's internal NLP"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_345getNlRows = {"getNlRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_345getNlRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_344getNlRows}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_345getNlRows(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNlRows (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNlRows", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNlRows", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_344getNlRows(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_344getNlRows(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_NLROW **__pyx_v_nlrows; + PyObject *__pyx_9genexpr39__pyx_v_i = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNlRows", 1); + + /* "src/pyscipopt/scip.pxi":3265 + * cdef SCIP_NLROW** nlrows + * + * nlrows = SCIPgetNLPNlRows(self._scip) # <<<<<<<<<<<<<< + * return [NLRow.create(nlrows[i]) for i in range(self.getNNlRows())] + * + */ + __pyx_v_nlrows = SCIPgetNLPNlRows(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":3266 + * + * nlrows = SCIPgetNLPNlRows(self._scip) + * return [NLRow.create(nlrows[i]) for i in range(self.getNNlRows())] # <<<<<<<<<<<<<< + * + * def getNlRowSolActivity(self, NLRow nlrow, Solution sol = None): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getNNlRows); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) { + __pyx_t_2 = __pyx_t_3; __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3266, __pyx_L5_error) + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3266, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 3266, __pyx_L5_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 3266, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely((0 < 0))) __PYX_ERR(0, 3266, __pyx_L5_error) + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + } + } else { + __pyx_t_3 = __pyx_t_7(__pyx_t_2); + if (unlikely(!__pyx_t_3)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 3266, __pyx_L5_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_9genexpr39__pyx_v_i, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyIndex_AsSsize_t(__pyx_9genexpr39__pyx_v_i); if (unlikely((__pyx_t_8 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3266, __pyx_L5_error) + __pyx_t_3 = __pyx_f_9pyscipopt_4scip_5NLRow_create((__pyx_v_nlrows[__pyx_t_8])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 3266, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_9genexpr39__pyx_v_i); __pyx_9genexpr39__pyx_v_i = 0; + goto __pyx_L9_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_9genexpr39__pyx_v_i); __pyx_9genexpr39__pyx_v_i = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3261 + * return SCIPgetNNLPNlRows(self._scip) + * + * def getNlRows(self): # <<<<<<<<<<<<<< + * """returns a list with the nonlinear rows in SCIP's internal NLP""" + * cdef SCIP_NLROW** nlrows + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNlRows", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_9genexpr39__pyx_v_i); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3268 + * return [NLRow.create(nlrows[i]) for i in range(self.getNNlRows())] + * + * def getNlRowSolActivity(self, NLRow nlrow, Solution sol = None): # <<<<<<<<<<<<<< + * """gives the activity of a nonlinear row for a given primal solution + * Keyword arguments: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_347getNlRowSolActivity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_346getNlRowSolActivity, "Model.getNlRowSolActivity(self, NLRow nlrow, Solution sol=None)\ngives the activity of a nonlinear row for a given primal solution\n Keyword arguments:\n nlrow -- nonlinear row\n solution -- a primal solution, if None, then the current LP solution is used\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_347getNlRowSolActivity = {"getNlRowSolActivity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_347getNlRowSolActivity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_346getNlRowSolActivity}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_347getNlRowSolActivity(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNlRowSolActivity (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nlrow,&__pyx_n_s_sol,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nlrow)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3268, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3268, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getNlRowSolActivity") < 0)) __PYX_ERR(0, 3268, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_nlrow = ((struct __pyx_obj_9pyscipopt_4scip_NLRow *)values[0]); + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getNlRowSolActivity", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3268, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getNlRowSolActivity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_nlrow), __pyx_ptype_9pyscipopt_4scip_NLRow, 1, "nlrow", 0))) __PYX_ERR(0, 3268, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 3268, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_346getNlRowSolActivity(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_nlrow, __pyx_v_sol); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_346getNlRowSolActivity(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol) { + SCIP_Real __pyx_v_activity; + SCIP_SOL *__pyx_v_solptr; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_SOL *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNlRowSolActivity", 1); + + /* "src/pyscipopt/scip.pxi":3277 + * cdef SCIP_SOL* solptr + * + * solptr = sol.sol if not sol is None else NULL # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPgetNlRowSolActivity(self._scip, nlrow.scip_nlrow, solptr, &activity) ) + * return activity + */ + __pyx_t_2 = (((PyObject *)__pyx_v_sol) != Py_None); + if (__pyx_t_2) { + __pyx_t_1 = __pyx_v_sol->sol; + } else { + __pyx_t_1 = NULL; + } + __pyx_v_solptr = __pyx_t_1; + + /* "src/pyscipopt/scip.pxi":3278 + * + * solptr = sol.sol if not sol is None else NULL + * PY_SCIP_CALL( SCIPgetNlRowSolActivity(self._scip, nlrow.scip_nlrow, solptr, &activity) ) # <<<<<<<<<<<<<< + * return activity + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetNlRowSolActivity(__pyx_v_self->_scip, __pyx_v_nlrow->scip_nlrow, __pyx_v_solptr, (&__pyx_v_activity))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3279 + * solptr = sol.sol if not sol is None else NULL + * PY_SCIP_CALL( SCIPgetNlRowSolActivity(self._scip, nlrow.scip_nlrow, solptr, &activity) ) + * return activity # <<<<<<<<<<<<<< + * + * def getNlRowSolFeasibility(self, NLRow nlrow, Solution sol = None): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_activity); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3268 + * return [NLRow.create(nlrows[i]) for i in range(self.getNNlRows())] + * + * def getNlRowSolActivity(self, NLRow nlrow, Solution sol = None): # <<<<<<<<<<<<<< + * """gives the activity of a nonlinear row for a given primal solution + * Keyword arguments: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNlRowSolActivity", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3281 + * return activity + * + * def getNlRowSolFeasibility(self, NLRow nlrow, Solution sol = None): # <<<<<<<<<<<<<< + * """gives the feasibility of a nonlinear row for a given primal solution + * Keyword arguments: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_349getNlRowSolFeasibility(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_348getNlRowSolFeasibility, "Model.getNlRowSolFeasibility(self, NLRow nlrow, Solution sol=None)\ngives the feasibility of a nonlinear row for a given primal solution\n Keyword arguments:\n nlrow -- nonlinear row\n solution -- a primal solution, if None, then the current LP solution is used\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_349getNlRowSolFeasibility = {"getNlRowSolFeasibility", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_349getNlRowSolFeasibility, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_348getNlRowSolFeasibility}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_349getNlRowSolFeasibility(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNlRowSolFeasibility (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nlrow,&__pyx_n_s_sol,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nlrow)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3281, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3281, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getNlRowSolFeasibility") < 0)) __PYX_ERR(0, 3281, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_nlrow = ((struct __pyx_obj_9pyscipopt_4scip_NLRow *)values[0]); + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getNlRowSolFeasibility", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3281, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getNlRowSolFeasibility", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_nlrow), __pyx_ptype_9pyscipopt_4scip_NLRow, 1, "nlrow", 0))) __PYX_ERR(0, 3281, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 3281, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_348getNlRowSolFeasibility(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_nlrow, __pyx_v_sol); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_348getNlRowSolFeasibility(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol) { + SCIP_Real __pyx_v_feasibility; + SCIP_SOL *__pyx_v_solptr; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_SOL *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNlRowSolFeasibility", 1); + + /* "src/pyscipopt/scip.pxi":3290 + * cdef SCIP_SOL* solptr + * + * solptr = sol.sol if not sol is None else NULL # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPgetNlRowSolFeasibility(self._scip, nlrow.scip_nlrow, solptr, &feasibility) ) + * return feasibility + */ + __pyx_t_2 = (((PyObject *)__pyx_v_sol) != Py_None); + if (__pyx_t_2) { + __pyx_t_1 = __pyx_v_sol->sol; + } else { + __pyx_t_1 = NULL; + } + __pyx_v_solptr = __pyx_t_1; + + /* "src/pyscipopt/scip.pxi":3291 + * + * solptr = sol.sol if not sol is None else NULL + * PY_SCIP_CALL( SCIPgetNlRowSolFeasibility(self._scip, nlrow.scip_nlrow, solptr, &feasibility) ) # <<<<<<<<<<<<<< + * return feasibility + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetNlRowSolFeasibility(__pyx_v_self->_scip, __pyx_v_nlrow->scip_nlrow, __pyx_v_solptr, (&__pyx_v_feasibility))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3292 + * solptr = sol.sol if not sol is None else NULL + * PY_SCIP_CALL( SCIPgetNlRowSolFeasibility(self._scip, nlrow.scip_nlrow, solptr, &feasibility) ) + * return feasibility # <<<<<<<<<<<<<< + * + * def getNlRowActivityBounds(self, NLRow nlrow): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_feasibility); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3281 + * return activity + * + * def getNlRowSolFeasibility(self, NLRow nlrow, Solution sol = None): # <<<<<<<<<<<<<< + * """gives the feasibility of a nonlinear row for a given primal solution + * Keyword arguments: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNlRowSolFeasibility", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3294 + * return feasibility + * + * def getNlRowActivityBounds(self, NLRow nlrow): # <<<<<<<<<<<<<< + * """gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds""" + * cdef SCIP_Real minactivity + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_351getNlRowActivityBounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_350getNlRowActivityBounds, "Model.getNlRowActivityBounds(self, NLRow nlrow)\ngives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_351getNlRowActivityBounds = {"getNlRowActivityBounds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_351getNlRowActivityBounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_350getNlRowActivityBounds}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_351getNlRowActivityBounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNlRowActivityBounds (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nlrow,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nlrow)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3294, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getNlRowActivityBounds") < 0)) __PYX_ERR(0, 3294, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_nlrow = ((struct __pyx_obj_9pyscipopt_4scip_NLRow *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getNlRowActivityBounds", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3294, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getNlRowActivityBounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_nlrow), __pyx_ptype_9pyscipopt_4scip_NLRow, 1, "nlrow", 0))) __PYX_ERR(0, 3294, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_350getNlRowActivityBounds(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_nlrow); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_350getNlRowActivityBounds(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow) { + SCIP_Real __pyx_v_minactivity; + SCIP_Real __pyx_v_maxactivity; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNlRowActivityBounds", 1); + + /* "src/pyscipopt/scip.pxi":3299 + * cdef SCIP_Real maxactivity + * + * PY_SCIP_CALL( SCIPgetNlRowActivityBounds(self._scip, nlrow.scip_nlrow, &minactivity, &maxactivity) ) # <<<<<<<<<<<<<< + * return (minactivity, maxactivity) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetNlRowActivityBounds(__pyx_v_self->_scip, __pyx_v_nlrow->scip_nlrow, (&__pyx_v_minactivity), (&__pyx_v_maxactivity))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3300 + * + * PY_SCIP_CALL( SCIPgetNlRowActivityBounds(self._scip, nlrow.scip_nlrow, &minactivity, &maxactivity) ) + * return (minactivity, maxactivity) # <<<<<<<<<<<<<< + * + * def printNlRow(self, NLRow nlrow): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_minactivity); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_maxactivity); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(0, 3300, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(0, 3300, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3294 + * return feasibility + * + * def getNlRowActivityBounds(self, NLRow nlrow): # <<<<<<<<<<<<<< + * """gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds""" + * cdef SCIP_Real minactivity + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNlRowActivityBounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3302 + * return (minactivity, maxactivity) + * + * def printNlRow(self, NLRow nlrow): # <<<<<<<<<<<<<< + * """prints nonlinear row""" + * PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) ) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_353printNlRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_352printNlRow, "Model.printNlRow(self, NLRow nlrow)\nprints nonlinear row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_353printNlRow = {"printNlRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_353printNlRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_352printNlRow}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_353printNlRow(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("printNlRow (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nlrow,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nlrow)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3302, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "printNlRow") < 0)) __PYX_ERR(0, 3302, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_nlrow = ((struct __pyx_obj_9pyscipopt_4scip_NLRow *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("printNlRow", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3302, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.printNlRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_nlrow), __pyx_ptype_9pyscipopt_4scip_NLRow, 1, "nlrow", 0))) __PYX_ERR(0, 3302, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_352printNlRow(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_nlrow); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_352printNlRow(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_NLRow *__pyx_v_nlrow) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("printNlRow", 1); + + /* "src/pyscipopt/scip.pxi":3304 + * def printNlRow(self, NLRow nlrow): + * """prints nonlinear row""" + * PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) ) # <<<<<<<<<<<<<< + * + * def checkQuadraticNonlinear(self, Constraint cons): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintNlRow(__pyx_v_self->_scip, __pyx_v_nlrow->scip_nlrow, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3304, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3302 + * return (minactivity, maxactivity) + * + * def printNlRow(self, NLRow nlrow): # <<<<<<<<<<<<<< + * """prints nonlinear row""" + * PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) ) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.printNlRow", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3306 + * PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) ) + * + * def checkQuadraticNonlinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """returns if the given constraint is quadratic + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_355checkQuadraticNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_354checkQuadraticNonlinear, "Model.checkQuadraticNonlinear(self, Constraint cons)\nreturns if the given constraint is quadratic\n\n :param Constraint cons: constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_355checkQuadraticNonlinear = {"checkQuadraticNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_355checkQuadraticNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_354checkQuadraticNonlinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_355checkQuadraticNonlinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("checkQuadraticNonlinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3306, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "checkQuadraticNonlinear") < 0)) __PYX_ERR(0, 3306, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("checkQuadraticNonlinear", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3306, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.checkQuadraticNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3306, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_354checkQuadraticNonlinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_354checkQuadraticNonlinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + SCIP_Bool __pyx_v_isquadratic; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("checkQuadraticNonlinear", 1); + + /* "src/pyscipopt/scip.pxi":3313 + * """ + * cdef SCIP_Bool isquadratic + * PY_SCIP_CALL( SCIPcheckQuadraticNonlinear(self._scip, cons.scip_cons, &isquadratic) ) # <<<<<<<<<<<<<< + * return isquadratic + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcheckQuadraticNonlinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, (&__pyx_v_isquadratic))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3314 + * cdef SCIP_Bool isquadratic + * PY_SCIP_CALL( SCIPcheckQuadraticNonlinear(self._scip, cons.scip_cons, &isquadratic) ) + * return isquadratic # <<<<<<<<<<<<<< + * + * def getTermsQuadratic(self, Constraint cons): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_isquadratic); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3306 + * PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) ) + * + * def checkQuadraticNonlinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """returns if the given constraint is quadratic + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.checkQuadraticNonlinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3316 + * return isquadratic + * + * def getTermsQuadratic(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve bilinear, quadratic, and linear terms of a quadratic constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_357getTermsQuadratic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_356getTermsQuadratic, "Model.getTermsQuadratic(self, Constraint cons)\nRetrieve bilinear, quadratic, and linear terms of a quadratic constraint.\n\n :param Constraint cons: constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_357getTermsQuadratic = {"getTermsQuadratic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_357getTermsQuadratic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_356getTermsQuadratic}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_357getTermsQuadratic(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getTermsQuadratic (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3316, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getTermsQuadratic") < 0)) __PYX_ERR(0, 3316, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getTermsQuadratic", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3316, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getTermsQuadratic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3316, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_356getTermsQuadratic(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_356getTermsQuadratic(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + SCIP_EXPR *__pyx_v_expr; + SCIP_EXPR **__pyx_v__linexprs; + SCIP_Real *__pyx_v__lincoefs; + int __pyx_v__nlinvars; + int __pyx_v__nbilinterms; + SCIP_EXPR *__pyx_v_bilinterm1; + SCIP_EXPR *__pyx_v_bilinterm2; + SCIP_Real __pyx_v_bilincoef; + int __pyx_v__nquadterms; + SCIP_Real __pyx_v_sqrcoef; + SCIP_Real __pyx_v_lincoef; + SCIP_EXPR *__pyx_v_sqrexpr; + SCIP_VAR *__pyx_v_scipvar1; + SCIP_VAR *__pyx_v_scipvar2; + PyObject *__pyx_v_linterms = NULL; + PyObject *__pyx_v_bilinterms = NULL; + PyObject *__pyx_v_quadterms = NULL; + int __pyx_v_termidx; + PyObject *__pyx_v_var = NULL; + PyObject *__pyx_v_var1 = NULL; + PyObject *__pyx_v_var2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getTermsQuadratic", 1); + + /* "src/pyscipopt/scip.pxi":3345 + * cdef SCIP_VAR* scipvar2 + * + * assert cons.isNonlinear(), "constraint is not nonlinear" # <<<<<<<<<<<<<< + * assert self.checkQuadraticNonlinear(cons), "constraint is not quadratic" + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cons), __pyx_n_s_isNonlinear); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3345, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_constraint_is_not_nonlinear, 0, 0); + __PYX_ERR(0, 3345, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 3345, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":3346 + * + * assert cons.isNonlinear(), "constraint is not nonlinear" + * assert self.checkQuadraticNonlinear(cons), "constraint is not quadratic" # <<<<<<<<<<<<<< + * + * expr = SCIPgetExprNonlinear(cons.scip_cons) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_checkQuadraticNonlinear); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_cons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3346, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3346, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_constraint_is_not_quadratic, 0, 0); + __PYX_ERR(0, 3346, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 3346, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":3348 + * assert self.checkQuadraticNonlinear(cons), "constraint is not quadratic" + * + * expr = SCIPgetExprNonlinear(cons.scip_cons) # <<<<<<<<<<<<<< + * SCIPexprGetQuadraticData(expr, NULL, &_nlinvars, &_linexprs, &_lincoefs, &_nquadterms, &_nbilinterms, NULL, NULL) + * + */ + __pyx_v_expr = SCIPgetExprNonlinear(__pyx_v_cons->scip_cons); + + /* "src/pyscipopt/scip.pxi":3349 + * + * expr = SCIPgetExprNonlinear(cons.scip_cons) + * SCIPexprGetQuadraticData(expr, NULL, &_nlinvars, &_linexprs, &_lincoefs, &_nquadterms, &_nbilinterms, NULL, NULL) # <<<<<<<<<<<<<< + * + * linterms = [] + */ + SCIPexprGetQuadraticData(__pyx_v_expr, NULL, (&__pyx_v__nlinvars), (&__pyx_v__linexprs), (&__pyx_v__lincoefs), (&__pyx_v__nquadterms), (&__pyx_v__nbilinterms), NULL, NULL); + + /* "src/pyscipopt/scip.pxi":3351 + * SCIPexprGetQuadraticData(expr, NULL, &_nlinvars, &_linexprs, &_lincoefs, &_nquadterms, &_nbilinterms, NULL, NULL) + * + * linterms = [] # <<<<<<<<<<<<<< + * bilinterms = [] + * quadterms = [] + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_linterms = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3352 + * + * linterms = [] + * bilinterms = [] # <<<<<<<<<<<<<< + * quadterms = [] + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bilinterms = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3353 + * linterms = [] + * bilinterms = [] + * quadterms = [] # <<<<<<<<<<<<<< + * + * for termidx in range(_nlinvars): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_quadterms = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3355 + * quadterms = [] + * + * for termidx in range(_nlinvars): # <<<<<<<<<<<<<< + * var = Variable.create(SCIPgetVarExprVar(_linexprs[termidx])) + * linterms.append((var,_lincoefs[termidx])) + */ + __pyx_t_4 = __pyx_v__nlinvars; + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_termidx = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":3356 + * + * for termidx in range(_nlinvars): + * var = Variable.create(SCIPgetVarExprVar(_linexprs[termidx])) # <<<<<<<<<<<<<< + * linterms.append((var,_lincoefs[termidx])) + * + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Variable_create(SCIPgetVarExprVar((__pyx_v__linexprs[__pyx_v_termidx]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3357 + * for termidx in range(_nlinvars): + * var = Variable.create(SCIPgetVarExprVar(_linexprs[termidx])) + * linterms.append((var,_lincoefs[termidx])) # <<<<<<<<<<<<<< + * + * for termidx in range(_nbilinterms): + */ + __pyx_t_1 = PyFloat_FromDouble((__pyx_v__lincoefs[__pyx_v_termidx])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_var); + __Pyx_GIVEREF(__pyx_v_var); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_var)) __PYX_ERR(0, 3357, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 3357, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_linterms, __pyx_t_2); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 3357, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + + /* "src/pyscipopt/scip.pxi":3359 + * linterms.append((var,_lincoefs[termidx])) + * + * for termidx in range(_nbilinterms): # <<<<<<<<<<<<<< + * SCIPexprGetQuadraticBilinTerm(expr, termidx, &bilinterm1, &bilinterm2, &bilincoef, NULL, NULL) + * scipvar1 = SCIPgetVarExprVar(bilinterm1) + */ + __pyx_t_4 = __pyx_v__nbilinterms; + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_termidx = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":3360 + * + * for termidx in range(_nbilinterms): + * SCIPexprGetQuadraticBilinTerm(expr, termidx, &bilinterm1, &bilinterm2, &bilincoef, NULL, NULL) # <<<<<<<<<<<<<< + * scipvar1 = SCIPgetVarExprVar(bilinterm1) + * scipvar2 = SCIPgetVarExprVar(bilinterm2) + */ + SCIPexprGetQuadraticBilinTerm(__pyx_v_expr, __pyx_v_termidx, (&__pyx_v_bilinterm1), (&__pyx_v_bilinterm2), (&__pyx_v_bilincoef), NULL, NULL); + + /* "src/pyscipopt/scip.pxi":3361 + * for termidx in range(_nbilinterms): + * SCIPexprGetQuadraticBilinTerm(expr, termidx, &bilinterm1, &bilinterm2, &bilincoef, NULL, NULL) + * scipvar1 = SCIPgetVarExprVar(bilinterm1) # <<<<<<<<<<<<<< + * scipvar2 = SCIPgetVarExprVar(bilinterm2) + * var1 = Variable.create(scipvar1) + */ + __pyx_v_scipvar1 = SCIPgetVarExprVar(__pyx_v_bilinterm1); + + /* "src/pyscipopt/scip.pxi":3362 + * SCIPexprGetQuadraticBilinTerm(expr, termidx, &bilinterm1, &bilinterm2, &bilincoef, NULL, NULL) + * scipvar1 = SCIPgetVarExprVar(bilinterm1) + * scipvar2 = SCIPgetVarExprVar(bilinterm2) # <<<<<<<<<<<<<< + * var1 = Variable.create(scipvar1) + * var2 = Variable.create(scipvar2) + */ + __pyx_v_scipvar2 = SCIPgetVarExprVar(__pyx_v_bilinterm2); + + /* "src/pyscipopt/scip.pxi":3363 + * scipvar1 = SCIPgetVarExprVar(bilinterm1) + * scipvar2 = SCIPgetVarExprVar(bilinterm2) + * var1 = Variable.create(scipvar1) # <<<<<<<<<<<<<< + * var2 = Variable.create(scipvar2) + * if scipvar1 != scipvar2: + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v_scipvar1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_var1, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3364 + * scipvar2 = SCIPgetVarExprVar(bilinterm2) + * var1 = Variable.create(scipvar1) + * var2 = Variable.create(scipvar2) # <<<<<<<<<<<<<< + * if scipvar1 != scipvar2: + * bilinterms.append((var1,var2,bilincoef)) + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v_scipvar2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_var2, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3365 + * var1 = Variable.create(scipvar1) + * var2 = Variable.create(scipvar2) + * if scipvar1 != scipvar2: # <<<<<<<<<<<<<< + * bilinterms.append((var1,var2,bilincoef)) + * else: + */ + __pyx_t_5 = (__pyx_v_scipvar1 != __pyx_v_scipvar2); + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":3366 + * var2 = Variable.create(scipvar2) + * if scipvar1 != scipvar2: + * bilinterms.append((var1,var2,bilincoef)) # <<<<<<<<<<<<<< + * else: + * quadterms.append((var1,bilincoef,0.0)) + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_bilincoef); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_var1); + __Pyx_GIVEREF(__pyx_v_var1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_var1)) __PYX_ERR(0, 3366, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_var2); + __Pyx_GIVEREF(__pyx_v_var2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_var2)) __PYX_ERR(0, 3366, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_2)) __PYX_ERR(0, 3366, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_bilinterms, __pyx_t_1); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 3366, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3365 + * var1 = Variable.create(scipvar1) + * var2 = Variable.create(scipvar2) + * if scipvar1 != scipvar2: # <<<<<<<<<<<<<< + * bilinterms.append((var1,var2,bilincoef)) + * else: + */ + goto __pyx_L7; + } + + /* "src/pyscipopt/scip.pxi":3368 + * bilinterms.append((var1,var2,bilincoef)) + * else: + * quadterms.append((var1,bilincoef,0.0)) # <<<<<<<<<<<<<< + * + * for termidx in range(_nquadterms): + */ + /*else*/ { + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_bilincoef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_var1); + __Pyx_GIVEREF(__pyx_v_var1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_var1)) __PYX_ERR(0, 3368, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1)) __PYX_ERR(0, 3368, __pyx_L1_error); + __Pyx_INCREF(__pyx_float_0_0); + __Pyx_GIVEREF(__pyx_float_0_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_float_0_0)) __PYX_ERR(0, 3368, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_quadterms, __pyx_t_2); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 3368, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L7:; + } + + /* "src/pyscipopt/scip.pxi":3370 + * quadterms.append((var1,bilincoef,0.0)) + * + * for termidx in range(_nquadterms): # <<<<<<<<<<<<<< + * SCIPexprGetQuadraticQuadTerm(expr, termidx, NULL, &lincoef, &sqrcoef, NULL, NULL, &sqrexpr) + * if sqrexpr == NULL: + */ + __pyx_t_4 = __pyx_v__nquadterms; + __pyx_t_6 = __pyx_t_4; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_termidx = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":3371 + * + * for termidx in range(_nquadterms): + * SCIPexprGetQuadraticQuadTerm(expr, termidx, NULL, &lincoef, &sqrcoef, NULL, NULL, &sqrexpr) # <<<<<<<<<<<<<< + * if sqrexpr == NULL: + * continue + */ + SCIPexprGetQuadraticQuadTerm(__pyx_v_expr, __pyx_v_termidx, NULL, (&__pyx_v_lincoef), (&__pyx_v_sqrcoef), NULL, NULL, (&__pyx_v_sqrexpr)); + + /* "src/pyscipopt/scip.pxi":3372 + * for termidx in range(_nquadterms): + * SCIPexprGetQuadraticQuadTerm(expr, termidx, NULL, &lincoef, &sqrcoef, NULL, NULL, &sqrexpr) + * if sqrexpr == NULL: # <<<<<<<<<<<<<< + * continue + * var = Variable.create(SCIPgetVarExprVar(sqrexpr)) + */ + __pyx_t_5 = (__pyx_v_sqrexpr == NULL); + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":3373 + * SCIPexprGetQuadraticQuadTerm(expr, termidx, NULL, &lincoef, &sqrcoef, NULL, NULL, &sqrexpr) + * if sqrexpr == NULL: + * continue # <<<<<<<<<<<<<< + * var = Variable.create(SCIPgetVarExprVar(sqrexpr)) + * quadterms.append((var,sqrcoef,lincoef)) + */ + goto __pyx_L8_continue; + + /* "src/pyscipopt/scip.pxi":3372 + * for termidx in range(_nquadterms): + * SCIPexprGetQuadraticQuadTerm(expr, termidx, NULL, &lincoef, &sqrcoef, NULL, NULL, &sqrexpr) + * if sqrexpr == NULL: # <<<<<<<<<<<<<< + * continue + * var = Variable.create(SCIPgetVarExprVar(sqrexpr)) + */ + } + + /* "src/pyscipopt/scip.pxi":3374 + * if sqrexpr == NULL: + * continue + * var = Variable.create(SCIPgetVarExprVar(sqrexpr)) # <<<<<<<<<<<<<< + * quadterms.append((var,sqrcoef,lincoef)) + * + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Variable_create(SCIPgetVarExprVar(__pyx_v_sqrexpr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3375 + * continue + * var = Variable.create(SCIPgetVarExprVar(sqrexpr)) + * quadterms.append((var,sqrcoef,lincoef)) # <<<<<<<<<<<<<< + * + * return (bilinterms, quadterms, linterms) + */ + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_sqrcoef); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_lincoef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_var); + __Pyx_GIVEREF(__pyx_v_var); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_var)) __PYX_ERR(0, 3375, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(0, 3375, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_1)) __PYX_ERR(0, 3375, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_quadterms, __pyx_t_3); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 3375, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_L8_continue:; + } + + /* "src/pyscipopt/scip.pxi":3377 + * quadterms.append((var,sqrcoef,lincoef)) + * + * return (bilinterms, quadterms, linterms) # <<<<<<<<<<<<<< + * + * def setRelaxSolVal(self, Variable var, val): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_bilinterms); + __Pyx_GIVEREF(__pyx_v_bilinterms); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_bilinterms)) __PYX_ERR(0, 3377, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_quadterms); + __Pyx_GIVEREF(__pyx_v_quadterms); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_quadterms)) __PYX_ERR(0, 3377, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_linterms); + __Pyx_GIVEREF(__pyx_v_linterms); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_linterms)) __PYX_ERR(0, 3377, __pyx_L1_error); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3316 + * return isquadratic + * + * def getTermsQuadratic(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve bilinear, quadratic, and linear terms of a quadratic constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.getTermsQuadratic", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_linterms); + __Pyx_XDECREF(__pyx_v_bilinterms); + __Pyx_XDECREF(__pyx_v_quadterms); + __Pyx_XDECREF(__pyx_v_var); + __Pyx_XDECREF(__pyx_v_var1); + __Pyx_XDECREF(__pyx_v_var2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3379 + * return (bilinterms, quadterms, linterms) + * + * def setRelaxSolVal(self, Variable var, val): # <<<<<<<<<<<<<< + * """sets the value of the given variable in the global relaxation solution""" + * PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_359setRelaxSolVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_358setRelaxSolVal, "Model.setRelaxSolVal(self, Variable var, val)\nsets the value of the given variable in the global relaxation solution"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_359setRelaxSolVal = {"setRelaxSolVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_359setRelaxSolVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_358setRelaxSolVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_359setRelaxSolVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_val = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setRelaxSolVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_val,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3379, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3379, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setRelaxSolVal", 1, 2, 2, 1); __PYX_ERR(0, 3379, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setRelaxSolVal") < 0)) __PYX_ERR(0, 3379, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_val = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setRelaxSolVal", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3379, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setRelaxSolVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3379, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_358setRelaxSolVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_val); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_358setRelaxSolVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_val) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setRelaxSolVal", 1); + + /* "src/pyscipopt/scip.pxi":3381 + * def setRelaxSolVal(self, Variable var, val): + * """sets the value of the given variable in the global relaxation solution""" + * PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val)) # <<<<<<<<<<<<<< + * + * def getConss(self, transformed=True): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_val); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3381, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetRelaxSolVal(__pyx_v_self->_scip, NULL, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3381, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3379 + * return (bilinterms, quadterms, linterms) + * + * def setRelaxSolVal(self, Variable var, val): # <<<<<<<<<<<<<< + * """sets the value of the given variable in the global relaxation solution""" + * PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.setRelaxSolVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3383 + * PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val)) + * + * def getConss(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve all constraints. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_361getConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_360getConss, "Model.getConss(self, transformed=True)\nRetrieve all constraints.\n \n :param transformed: get transformed variables instead of original (Default value = True)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_361getConss = {"getConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_361getConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_360getConss}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_361getConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_transformed = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getConss (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_transformed,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_transformed); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3383, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getConss") < 0)) __PYX_ERR(0, 3383, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_transformed = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getConss", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 3383, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getConss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_360getConss(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_transformed); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_360getConss(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_transformed) { + SCIP_CONS **__pyx_v__conss; + int __pyx_v__nconss; + CYTHON_UNUSED PyObject *__pyx_v_conss = NULL; + int __pyx_9genexpr40__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getConss", 1); + + /* "src/pyscipopt/scip.pxi":3390 + * cdef SCIP_CONS** _conss + * cdef int _nconss + * conss = [] # <<<<<<<<<<<<<< + * + * if transformed: + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_conss = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3392 + * conss = [] + * + * if transformed: # <<<<<<<<<<<<<< + * _conss = SCIPgetConss(self._scip) + * _nconss = SCIPgetNConss(self._scip) + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_transformed); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 3392, __pyx_L1_error) + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":3393 + * + * if transformed: + * _conss = SCIPgetConss(self._scip) # <<<<<<<<<<<<<< + * _nconss = SCIPgetNConss(self._scip) + * else: + */ + __pyx_v__conss = SCIPgetConss(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":3394 + * if transformed: + * _conss = SCIPgetConss(self._scip) + * _nconss = SCIPgetNConss(self._scip) # <<<<<<<<<<<<<< + * else: + * _conss = SCIPgetOrigConss(self._scip) + */ + __pyx_v__nconss = SCIPgetNConss(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":3392 + * conss = [] + * + * if transformed: # <<<<<<<<<<<<<< + * _conss = SCIPgetConss(self._scip) + * _nconss = SCIPgetNConss(self._scip) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3396 + * _nconss = SCIPgetNConss(self._scip) + * else: + * _conss = SCIPgetOrigConss(self._scip) # <<<<<<<<<<<<<< + * _nconss = SCIPgetNOrigConss(self._scip) + * return [Constraint.create(_conss[i]) for i in range(_nconss)] + */ + /*else*/ { + __pyx_v__conss = SCIPgetOrigConss(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":3397 + * else: + * _conss = SCIPgetOrigConss(self._scip) + * _nconss = SCIPgetNOrigConss(self._scip) # <<<<<<<<<<<<<< + * return [Constraint.create(_conss[i]) for i in range(_nconss)] + * + */ + __pyx_v__nconss = SCIPgetNOrigConss(__pyx_v_self->_scip); + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3398 + * _conss = SCIPgetOrigConss(self._scip) + * _nconss = SCIPgetNOrigConss(self._scip) + * return [Constraint.create(_conss[i]) for i in range(_nconss)] # <<<<<<<<<<<<<< + * + * def getNConss(self, transformed=True): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __pyx_v__nconss; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_9genexpr40__pyx_v_i = __pyx_t_5; + __pyx_t_6 = __pyx_f_9pyscipopt_4scip_10Constraint_create((__pyx_v__conss[__pyx_9genexpr40__pyx_v_i])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 3398, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3383 + * PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val)) + * + * def getConss(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve all constraints. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.getConss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_conss); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3400 + * return [Constraint.create(_conss[i]) for i in range(_nconss)] + * + * def getNConss(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve number of all constraints""" + * if transformed: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_363getNConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_362getNConss, "Model.getNConss(self, transformed=True)\nRetrieve number of all constraints"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_363getNConss = {"getNConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_363getNConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_362getNConss}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_363getNConss(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_transformed = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNConss (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_transformed,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_transformed); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3400, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getNConss") < 0)) __PYX_ERR(0, 3400, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_transformed = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getNConss", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 3400, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getNConss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_362getNConss(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_transformed); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_362getNConss(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_transformed) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNConss", 1); + + /* "src/pyscipopt/scip.pxi":3402 + * def getNConss(self, transformed=True): + * """Retrieve number of all constraints""" + * if transformed: # <<<<<<<<<<<<<< + * return SCIPgetNConss(self._scip) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_transformed); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3402, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3403 + * """Retrieve number of all constraints""" + * if transformed: + * return SCIPgetNConss(self._scip) # <<<<<<<<<<<<<< + * else: + * return SCIPgetNOrigConss(self._scip) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(SCIPgetNConss(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3402 + * def getNConss(self, transformed=True): + * """Retrieve number of all constraints""" + * if transformed: # <<<<<<<<<<<<<< + * return SCIPgetNConss(self._scip) + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":3405 + * return SCIPgetNConss(self._scip) + * else: + * return SCIPgetNOrigConss(self._scip) # <<<<<<<<<<<<<< + * + * def delCons(self, Constraint cons): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(SCIPgetNOrigConss(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":3400 + * return [Constraint.create(_conss[i]) for i in range(_nconss)] + * + * def getNConss(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve number of all constraints""" + * if transformed: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNConss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3407 + * return SCIPgetNOrigConss(self._scip) + * + * def delCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Delete constraint from the model + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_365delCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_364delCons, "Model.delCons(self, Constraint cons)\nDelete constraint from the model\n\n :param Constraint cons: constraint to be deleted\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_365delCons = {"delCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_365delCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_364delCons}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_365delCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("delCons (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3407, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delCons") < 0)) __PYX_ERR(0, 3407, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delCons", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3407, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.delCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3407, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_364delCons(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_364delCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("delCons", 1); + + /* "src/pyscipopt/scip.pxi":3413 + * + * """ + * PY_SCIP_CALL(SCIPdelCons(self._scip, cons.scip_cons)) # <<<<<<<<<<<<<< + * + * def delConsLocal(self, Constraint cons): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPdelCons(__pyx_v_self->_scip, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3407 + * return SCIPgetNOrigConss(self._scip) + * + * def delCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Delete constraint from the model + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.delCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3415 + * PY_SCIP_CALL(SCIPdelCons(self._scip, cons.scip_cons)) + * + * def delConsLocal(self, Constraint cons): # <<<<<<<<<<<<<< + * """Delete constraint from the current node and it's children + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_367delConsLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_366delConsLocal, "Model.delConsLocal(self, Constraint cons)\nDelete constraint from the current node and it's children\n\n :param Constraint cons: constraint to be deleted\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_367delConsLocal = {"delConsLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_367delConsLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_366delConsLocal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_367delConsLocal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("delConsLocal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3415, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delConsLocal") < 0)) __PYX_ERR(0, 3415, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delConsLocal", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3415, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.delConsLocal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3415, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_366delConsLocal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_366delConsLocal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("delConsLocal", 1); + + /* "src/pyscipopt/scip.pxi":3421 + * + * """ + * PY_SCIP_CALL(SCIPdelConsLocal(self._scip, cons.scip_cons)) # <<<<<<<<<<<<<< + * + * def getValsLinear(self, Constraint cons): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPdelConsLocal(__pyx_v_self->_scip, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3415 + * PY_SCIP_CALL(SCIPdelCons(self._scip, cons.scip_cons)) + * + * def delConsLocal(self, Constraint cons): # <<<<<<<<<<<<<< + * """Delete constraint from the current node and it's children + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.delConsLocal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3423 + * PY_SCIP_CALL(SCIPdelConsLocal(self._scip, cons.scip_cons)) + * + * def getValsLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the coefficients of a linear constraint + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_369getValsLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_368getValsLinear, "Model.getValsLinear(self, Constraint cons)\nRetrieve the coefficients of a linear constraint\n\n :param Constraint cons: linear constraint to get the coefficients of\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_369getValsLinear = {"getValsLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_369getValsLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_368getValsLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_369getValsLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getValsLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3423, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getValsLinear") < 0)) __PYX_ERR(0, 3423, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getValsLinear", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3423, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getValsLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3423, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_368getValsLinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_368getValsLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + SCIP_Real *__pyx_v__vals; + SCIP_VAR **__pyx_v__vars; + PyObject *__pyx_v_constype = NULL; + PyObject *__pyx_v_valsdict = NULL; + int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getValsLinear", 1); + + /* "src/pyscipopt/scip.pxi":3432 + * cdef SCIP_VAR** _vars + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if not constype == 'linear': + * raise Warning("coefficients not available for constraints of type ", constype) + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3433 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': # <<<<<<<<<<<<<< + * raise Warning("coefficients not available for constraints of type ", constype) + * + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3433, __pyx_L1_error) + __pyx_t_4 = (!__pyx_t_3); + if (unlikely(__pyx_t_4)) { + + /* "src/pyscipopt/scip.pxi":3434 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': + * raise Warning("coefficients not available for constraints of type ", constype) # <<<<<<<<<<<<<< + * + * _vals = SCIPgetValsLinear(self._scip, cons.scip_cons) + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_kp_u_coefficients_not_available_for_c); + __Pyx_GIVEREF(__pyx_kp_u_coefficients_not_available_for_c); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_coefficients_not_available_for_c)) __PYX_ERR(0, 3434, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_constype); + __Pyx_GIVEREF(__pyx_v_constype); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_constype)) __PYX_ERR(0, 3434, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 3434, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3433 + * + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': # <<<<<<<<<<<<<< + * raise Warning("coefficients not available for constraints of type ", constype) + * + */ + } + + /* "src/pyscipopt/scip.pxi":3436 + * raise Warning("coefficients not available for constraints of type ", constype) + * + * _vals = SCIPgetValsLinear(self._scip, cons.scip_cons) # <<<<<<<<<<<<<< + * _vars = SCIPgetVarsLinear(self._scip, cons.scip_cons) + * + */ + __pyx_v__vals = SCIPgetValsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons); + + /* "src/pyscipopt/scip.pxi":3437 + * + * _vals = SCIPgetValsLinear(self._scip, cons.scip_cons) + * _vars = SCIPgetVarsLinear(self._scip, cons.scip_cons) # <<<<<<<<<<<<<< + * + * valsdict = {} + */ + __pyx_v__vars = SCIPgetVarsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons); + + /* "src/pyscipopt/scip.pxi":3439 + * _vars = SCIPgetVarsLinear(self._scip, cons.scip_cons) + * + * valsdict = {} # <<<<<<<<<<<<<< + * for i in range(SCIPgetNVarsLinear(self._scip, cons.scip_cons)): + * valsdict[bytes(SCIPvarGetName(_vars[i])).decode('utf-8')] = _vals[i] + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_valsdict = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3440 + * + * valsdict = {} + * for i in range(SCIPgetNVarsLinear(self._scip, cons.scip_cons)): # <<<<<<<<<<<<<< + * valsdict[bytes(SCIPvarGetName(_vars[i])).decode('utf-8')] = _vals[i] + * return valsdict + */ + __pyx_t_5 = SCIPgetNVarsLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons); + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_i = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":3441 + * valsdict = {} + * for i in range(SCIPgetNVarsLinear(self._scip, cons.scip_cons)): + * valsdict[bytes(SCIPvarGetName(_vars[i])).decode('utf-8')] = _vals[i] # <<<<<<<<<<<<<< + * return valsdict + * + */ + __pyx_t_2 = PyFloat_FromDouble((__pyx_v__vals[__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPvarGetName((__pyx_v__vars[__pyx_v_i]))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_8 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_8, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_valsdict, __pyx_t_1, __pyx_t_2) < 0))) __PYX_ERR(0, 3441, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + + /* "src/pyscipopt/scip.pxi":3442 + * for i in range(SCIPgetNVarsLinear(self._scip, cons.scip_cons)): + * valsdict[bytes(SCIPvarGetName(_vars[i])).decode('utf-8')] = _vals[i] + * return valsdict # <<<<<<<<<<<<<< + * + * def getRowLinear(self, Constraint cons): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_valsdict); + __pyx_r = __pyx_v_valsdict; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3423 + * PY_SCIP_CALL(SCIPdelConsLocal(self._scip, cons.scip_cons)) + * + * def getValsLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the coefficients of a linear constraint + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.getValsLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XDECREF(__pyx_v_valsdict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3444 + * return valsdict + * + * def getRowLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the linear relaxation of the given linear constraint as a row. + * may return NULL if no LP row was yet created; the user must not modify the row! + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_371getRowLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_370getRowLinear, "Model.getRowLinear(self, Constraint cons)\nRetrieve the linear relaxation of the given linear constraint as a row.\n may return NULL if no LP row was yet created; the user must not modify the row!\n\n :param Constraint cons: linear constraint to get the coefficients of\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_371getRowLinear = {"getRowLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_371getRowLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_370getRowLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_371getRowLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getRowLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3444, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getRowLinear") < 0)) __PYX_ERR(0, 3444, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getRowLinear", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3444, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3444, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_370getRowLinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_370getRowLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_v_constype = NULL; + SCIP_ROW *__pyx_v_row; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getRowLinear", 1); + + /* "src/pyscipopt/scip.pxi":3451 + * + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if not constype == 'linear': + * raise Warning("coefficients not available for constraints of type ", constype) + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3452 + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': # <<<<<<<<<<<<<< + * raise Warning("coefficients not available for constraints of type ", constype) + * + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3452, __pyx_L1_error) + __pyx_t_4 = (!__pyx_t_3); + if (unlikely(__pyx_t_4)) { + + /* "src/pyscipopt/scip.pxi":3453 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': + * raise Warning("coefficients not available for constraints of type ", constype) # <<<<<<<<<<<<<< + * + * cdef SCIP_ROW* row = SCIPgetRowLinear(self._scip, cons.scip_cons) + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3453, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_kp_u_coefficients_not_available_for_c); + __Pyx_GIVEREF(__pyx_kp_u_coefficients_not_available_for_c); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_coefficients_not_available_for_c)) __PYX_ERR(0, 3453, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_constype); + __Pyx_GIVEREF(__pyx_v_constype); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_constype)) __PYX_ERR(0, 3453, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3453, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 3453, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3452 + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': # <<<<<<<<<<<<<< + * raise Warning("coefficients not available for constraints of type ", constype) + * + */ + } + + /* "src/pyscipopt/scip.pxi":3455 + * raise Warning("coefficients not available for constraints of type ", constype) + * + * cdef SCIP_ROW* row = SCIPgetRowLinear(self._scip, cons.scip_cons) # <<<<<<<<<<<<<< + * return Row.create(row) + * + */ + __pyx_v_row = SCIPgetRowLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons); + + /* "src/pyscipopt/scip.pxi":3456 + * + * cdef SCIP_ROW* row = SCIPgetRowLinear(self._scip, cons.scip_cons) + * return Row.create(row) # <<<<<<<<<<<<<< + * + * def getDualsolLinear(self, Constraint cons): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_3Row_create(__pyx_v_row); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3456, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3444 + * return valsdict + * + * def getRowLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the linear relaxation of the given linear constraint as a row. + * may return NULL if no LP row was yet created; the user must not modify the row! + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getRowLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3458 + * return Row.create(row) + * + * def getDualsolLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the dual solution to a linear constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_373getDualsolLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_372getDualsolLinear, "Model.getDualsolLinear(self, Constraint cons)\nRetrieve the dual solution to a linear constraint.\n\n :param Constraint cons: linear constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_373getDualsolLinear = {"getDualsolLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_373getDualsolLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_372getDualsolLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_373getDualsolLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDualsolLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3458, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getDualsolLinear") < 0)) __PYX_ERR(0, 3458, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getDualsolLinear", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3458, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualsolLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3458, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_372getDualsolLinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_372getDualsolLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_v_constype = NULL; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_transcons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDualsolLinear", 1); + + /* "src/pyscipopt/scip.pxi":3464 + * + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') # <<<<<<<<<<<<<< + * if not constype == 'linear': + * raise Warning("dual solution values not available for constraints of type ", constype) + */ + __pyx_t_1 = __Pyx_PyBytes_FromString(SCIPconshdlrGetName(SCIPconsGetHdlr(__pyx_v_cons->scip_cons))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyBytes_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_decode_bytes(__pyx_t_2, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_constype = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3465 + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': # <<<<<<<<<<<<<< + * raise Warning("dual solution values not available for constraints of type ", constype) + * if cons.isOriginal(): + */ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_constype, __pyx_n_u_linear, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 3465, __pyx_L1_error) + __pyx_t_4 = (!__pyx_t_3); + if (unlikely(__pyx_t_4)) { + + /* "src/pyscipopt/scip.pxi":3466 + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': + * raise Warning("dual solution values not available for constraints of type ", constype) # <<<<<<<<<<<<<< + * if cons.isOriginal(): + * transcons = self.getTransformedCons(cons) + */ + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_kp_u_dual_solution_values_not_availab); + __Pyx_GIVEREF(__pyx_kp_u_dual_solution_values_not_availab); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_dual_solution_values_not_availab)) __PYX_ERR(0, 3466, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_constype); + __Pyx_GIVEREF(__pyx_v_constype); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_constype)) __PYX_ERR(0, 3466, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 3466, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3465 + * """ + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8') + * if not constype == 'linear': # <<<<<<<<<<<<<< + * raise Warning("dual solution values not available for constraints of type ", constype) + * if cons.isOriginal(): + */ + } + + /* "src/pyscipopt/scip.pxi":3467 + * if not constype == 'linear': + * raise Warning("dual solution values not available for constraints of type ", constype) + * if cons.isOriginal(): # <<<<<<<<<<<<<< + * transcons = self.getTransformedCons(cons) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cons), __pyx_n_s_isOriginal); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3467, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 3467, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_4) { + + /* "src/pyscipopt/scip.pxi":3468 + * raise Warning("dual solution values not available for constraints of type ", constype) + * if cons.isOriginal(): + * transcons = self.getTransformedCons(cons) # <<<<<<<<<<<<<< + * else: + * transcons = cons + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTransformedCons); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, ((PyObject *)__pyx_v_cons)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_1 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_transcons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3467 + * if not constype == 'linear': + * raise Warning("dual solution values not available for constraints of type ", constype) + * if cons.isOriginal(): # <<<<<<<<<<<<<< + * transcons = self.getTransformedCons(cons) + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3470 + * transcons = self.getTransformedCons(cons) + * else: + * transcons = cons # <<<<<<<<<<<<<< + * return SCIPgetDualsolLinear(self._scip, transcons.scip_cons) + * + */ + /*else*/ { + __Pyx_INCREF((PyObject *)__pyx_v_cons); + __pyx_v_transcons = __pyx_v_cons; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3471 + * else: + * transcons = cons + * return SCIPgetDualsolLinear(self._scip, transcons.scip_cons) # <<<<<<<<<<<<<< + * + * def getDualMultiplier(self, Constraint cons): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetDualsolLinear(__pyx_v_self->_scip, __pyx_v_transcons->scip_cons)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3471, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3458 + * return Row.create(row) + * + * def getDualsolLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the dual solution to a linear constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualsolLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_constype); + __Pyx_XDECREF((PyObject *)__pyx_v_transcons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3473 + * return SCIPgetDualsolLinear(self._scip, transcons.scip_cons) + * + * def getDualMultiplier(self, Constraint cons): # <<<<<<<<<<<<<< + * """DEPRECATED: Retrieve the dual solution to a linear constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_375getDualMultiplier(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_374getDualMultiplier, "Model.getDualMultiplier(self, Constraint cons)\nDEPRECATED: Retrieve the dual solution to a linear constraint.\n\n :param Constraint cons: linear constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_375getDualMultiplier = {"getDualMultiplier", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_375getDualMultiplier, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_374getDualMultiplier}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_375getDualMultiplier(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDualMultiplier (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3473, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getDualMultiplier") < 0)) __PYX_ERR(0, 3473, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getDualMultiplier", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3473, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualMultiplier", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3473, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_374getDualMultiplier(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_374getDualMultiplier(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDualMultiplier", 1); + + /* "src/pyscipopt/scip.pxi":3479 + * + * """ + * raise Warning("model.getDualMultiplier(cons) is deprecated: please use model.getDualsolLinear(cons)") # <<<<<<<<<<<<<< + * return self.getDualsolLinear(cons) + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__98, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 3479, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3473 + * return SCIPgetDualsolLinear(self._scip, transcons.scip_cons) + * + * def getDualMultiplier(self, Constraint cons): # <<<<<<<<<<<<<< + * """DEPRECATED: Retrieve the dual solution to a linear constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualMultiplier", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3482 + * return self.getDualsolLinear(cons) + * + * def getDualfarkasLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the dual farkas value to a linear constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_377getDualfarkasLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_376getDualfarkasLinear, "Model.getDualfarkasLinear(self, Constraint cons)\nRetrieve the dual farkas value to a linear constraint.\n\n :param Constraint cons: linear constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_377getDualfarkasLinear = {"getDualfarkasLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_377getDualfarkasLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_376getDualfarkasLinear}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_377getDualfarkasLinear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDualfarkasLinear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3482, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getDualfarkasLinear") < 0)) __PYX_ERR(0, 3482, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getDualfarkasLinear", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3482, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualfarkasLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3482, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_376getDualfarkasLinear(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_376getDualfarkasLinear(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_transcons = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDualfarkasLinear", 1); + + /* "src/pyscipopt/scip.pxi":3489 + * """ + * # TODO this should ideally be handled on the SCIP side + * if cons.isOriginal(): # <<<<<<<<<<<<<< + * transcons = self.getTransformedCons(cons) + * return SCIPgetDualfarkasLinear(self._scip, transcons.scip_cons) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cons), __pyx_n_s_isOriginal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 3489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":3490 + * # TODO this should ideally be handled on the SCIP side + * if cons.isOriginal(): + * transcons = self.getTransformedCons(cons) # <<<<<<<<<<<<<< + * return SCIPgetDualfarkasLinear(self._scip, transcons.scip_cons) + * else: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getTransformedCons); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_cons)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_transcons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3491 + * if cons.isOriginal(): + * transcons = self.getTransformedCons(cons) + * return SCIPgetDualfarkasLinear(self._scip, transcons.scip_cons) # <<<<<<<<<<<<<< + * else: + * return SCIPgetDualfarkasLinear(self._scip, cons.scip_cons) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetDualfarkasLinear(__pyx_v_self->_scip, __pyx_v_transcons->scip_cons)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3489 + * """ + * # TODO this should ideally be handled on the SCIP side + * if cons.isOriginal(): # <<<<<<<<<<<<<< + * transcons = self.getTransformedCons(cons) + * return SCIPgetDualfarkasLinear(self._scip, transcons.scip_cons) + */ + } + + /* "src/pyscipopt/scip.pxi":3493 + * return SCIPgetDualfarkasLinear(self._scip, transcons.scip_cons) + * else: + * return SCIPgetDualfarkasLinear(self._scip, cons.scip_cons) # <<<<<<<<<<<<<< + * + * def getVarRedcost(self, Variable var): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetDualfarkasLinear(__pyx_v_self->_scip, __pyx_v_cons->scip_cons)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":3482 + * return self.getDualsolLinear(cons) + * + * def getDualfarkasLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the dual farkas value to a linear constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualfarkasLinear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_transcons); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3495 + * return SCIPgetDualfarkasLinear(self._scip, cons.scip_cons) + * + * def getVarRedcost(self, Variable var): # <<<<<<<<<<<<<< + * """Retrieve the reduced cost of a variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_379getVarRedcost(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_378getVarRedcost, "Model.getVarRedcost(self, Variable var)\nRetrieve the reduced cost of a variable.\n\n :param Variable var: variable to get the reduced cost of\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_379getVarRedcost = {"getVarRedcost", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_379getVarRedcost, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_378getVarRedcost}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_379getVarRedcost(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVarRedcost (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3495, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getVarRedcost") < 0)) __PYX_ERR(0, 3495, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getVarRedcost", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3495, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getVarRedcost", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3495, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_378getVarRedcost(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_378getVarRedcost(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + PyObject *__pyx_v_redcost = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVarRedcost", 1); + + /* "src/pyscipopt/scip.pxi":3501 + * + * """ + * redcost = None # <<<<<<<<<<<<<< + * try: + * redcost = SCIPgetVarRedcost(self._scip, var.scip_var) + */ + __Pyx_INCREF(Py_None); + __pyx_v_redcost = Py_None; + + /* "src/pyscipopt/scip.pxi":3502 + * """ + * redcost = None + * try: # <<<<<<<<<<<<<< + * redcost = SCIPgetVarRedcost(self._scip, var.scip_var) + * if self.getObjectiveSense() == "maximize": + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "src/pyscipopt/scip.pxi":3503 + * redcost = None + * try: + * redcost = SCIPgetVarRedcost(self._scip, var.scip_var) # <<<<<<<<<<<<<< + * if self.getObjectiveSense() == "maximize": + * redcost = -redcost + */ + __pyx_t_4 = PyFloat_FromDouble(SCIPgetVarRedcost(__pyx_v_self->_scip, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3503, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_redcost, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":3504 + * try: + * redcost = SCIPgetVarRedcost(self._scip, var.scip_var) + * if self.getObjectiveSense() == "maximize": # <<<<<<<<<<<<<< + * redcost = -redcost + * except: + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getObjectiveSense); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3504, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 0+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3504, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_8 = (__Pyx_PyUnicode_Equals(__pyx_t_4, __pyx_n_u_maximize, Py_EQ)); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 3504, __pyx_L3_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_8) { + + /* "src/pyscipopt/scip.pxi":3505 + * redcost = SCIPgetVarRedcost(self._scip, var.scip_var) + * if self.getObjectiveSense() == "maximize": + * redcost = -redcost # <<<<<<<<<<<<<< + * except: + * raise Warning("no reduced cost available for variable " + var.name) + */ + __pyx_t_4 = PyNumber_Negative(__pyx_v_redcost); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3505, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF_SET(__pyx_v_redcost, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":3504 + * try: + * redcost = SCIPgetVarRedcost(self._scip, var.scip_var) + * if self.getObjectiveSense() == "maximize": # <<<<<<<<<<<<<< + * redcost = -redcost + * except: + */ + } + + /* "src/pyscipopt/scip.pxi":3502 + * """ + * redcost = None + * try: # <<<<<<<<<<<<<< + * redcost = SCIPgetVarRedcost(self._scip, var.scip_var) + * if self.getObjectiveSense() == "maximize": + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":3506 + * if self.getObjectiveSense() == "maximize": + * redcost = -redcost + * except: # <<<<<<<<<<<<<< + * raise Warning("no reduced cost available for variable " + var.name) + * return redcost + */ + /*except:*/ { + __Pyx_AddTraceback("pyscipopt.scip.Model.getVarRedcost", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(0, 3506, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + + /* "src/pyscipopt/scip.pxi":3507 + * redcost = -redcost + * except: + * raise Warning("no reduced cost available for variable " + var.name) # <<<<<<<<<<<<<< + * return redcost + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_var), __pyx_n_s_name); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3507, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = PyNumber_Add(__pyx_kp_u_no_reduced_cost_available_for_va, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3507, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3507, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_Raise(__pyx_t_9, 0, 0, 0); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __PYX_ERR(0, 3507, __pyx_L5_except_error) + } + + /* "src/pyscipopt/scip.pxi":3502 + * """ + * redcost = None + * try: # <<<<<<<<<<<<<< + * redcost = SCIPgetVarRedcost(self._scip, var.scip_var) + * if self.getObjectiveSense() == "maximize": + */ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "src/pyscipopt/scip.pxi":3508 + * except: + * raise Warning("no reduced cost available for variable " + var.name) + * return redcost # <<<<<<<<<<<<<< + * + * def getDualSolVal(self, Constraint cons, boundconstraint=False): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_redcost); + __pyx_r = __pyx_v_redcost; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3495 + * return SCIPgetDualfarkasLinear(self._scip, cons.scip_cons) + * + * def getVarRedcost(self, Variable var): # <<<<<<<<<<<<<< + * """Retrieve the reduced cost of a variable. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pyscipopt.scip.Model.getVarRedcost", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_redcost); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3510 + * return redcost + * + * def getDualSolVal(self, Constraint cons, boundconstraint=False): # <<<<<<<<<<<<<< + * """Retrieve returns dual solution value of a constraint. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_381getDualSolVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_380getDualSolVal, "Model.getDualSolVal(self, Constraint cons, boundconstraint=False)\nRetrieve returns dual solution value of a constraint.\n\n :param Constraint cons: constraint to get the dual solution value of\n :param boundconstraint bool: Decides whether to store a bool if the constraint is a bound constraint\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_381getDualSolVal = {"getDualSolVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_381getDualSolVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_380getDualSolVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_381getDualSolVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons = 0; + PyObject *__pyx_v_boundconstraint = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDualSolVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cons,&__pyx_n_s_boundconstraint,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cons)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3510, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_boundconstraint); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3510, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getDualSolVal") < 0)) __PYX_ERR(0, 3510, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_cons = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)values[0]); + __pyx_v_boundconstraint = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getDualSolVal", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3510, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualSolVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cons), __pyx_ptype_9pyscipopt_4scip_Constraint, 1, "cons", 0))) __PYX_ERR(0, 3510, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_380getDualSolVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cons, __pyx_v_boundconstraint); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_380getDualSolVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_cons, PyObject *__pyx_v_boundconstraint) { + SCIP_Real __pyx_v__dualsol; + SCIP_Bool __pyx_v__bounded; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDualSolVal", 1); + + /* "src/pyscipopt/scip.pxi":3520 + * cdef SCIP_Bool _bounded + * + * if boundconstraint: # <<<<<<<<<<<<<< + * SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, &_bounded) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_boundconstraint); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3520, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3521 + * + * if boundconstraint: + * SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, &_bounded) # <<<<<<<<<<<<<< + * else: + * SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, NULL) + */ + (void)(SCIPgetDualSolVal(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, (&__pyx_v__dualsol), (&__pyx_v__bounded))); + + /* "src/pyscipopt/scip.pxi":3520 + * cdef SCIP_Bool _bounded + * + * if boundconstraint: # <<<<<<<<<<<<<< + * SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, &_bounded) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3523 + * SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, &_bounded) + * else: + * SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, NULL) # <<<<<<<<<<<<<< + * + * return _dualsol + */ + /*else*/ { + (void)(SCIPgetDualSolVal(__pyx_v_self->_scip, __pyx_v_cons->scip_cons, (&__pyx_v__dualsol), NULL)); + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3525 + * SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, NULL) + * + * return _dualsol # <<<<<<<<<<<<<< + * + * def optimize(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(__pyx_v__dualsol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3510 + * return redcost + * + * def getDualSolVal(self, Constraint cons, boundconstraint=False): # <<<<<<<<<<<<<< + * """Retrieve returns dual solution value of a constraint. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualSolVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3527 + * return _dualsol + * + * def optimize(self): # <<<<<<<<<<<<<< + * """Optimize the problem.""" + * PY_SCIP_CALL(SCIPsolve(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_383optimize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_382optimize, "Model.optimize(self)\nOptimize the problem."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_383optimize = {"optimize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_383optimize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_382optimize}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_383optimize(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("optimize (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("optimize", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "optimize", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_382optimize(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_382optimize(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("optimize", 1); + + /* "src/pyscipopt/scip.pxi":3529 + * def optimize(self): + * """Optimize the problem.""" + * PY_SCIP_CALL(SCIPsolve(self._scip)) # <<<<<<<<<<<<<< + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsolve(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3530 + * """Optimize the problem.""" + * PY_SCIP_CALL(SCIPsolve(self._scip)) + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) # <<<<<<<<<<<<<< + * + * def solveConcurrent(self): + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, SCIPgetBestSol(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3530, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Solution))))) __PYX_ERR(0, 3530, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->_bestSol); + __Pyx_DECREF((PyObject *)__pyx_v_self->_bestSol); + __pyx_v_self->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3527 + * return _dualsol + * + * def optimize(self): # <<<<<<<<<<<<<< + * """Optimize the problem.""" + * PY_SCIP_CALL(SCIPsolve(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.optimize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3532 + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * + * def solveConcurrent(self): # <<<<<<<<<<<<<< + * """Transforms, presolves, and solves problem using additional solvers which emphasize on + * finding solutions.""" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_385solveConcurrent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_384solveConcurrent, "Model.solveConcurrent(self)\nTransforms, presolves, and solves problem using additional solvers which emphasize on\n finding solutions."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_385solveConcurrent = {"solveConcurrent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_385solveConcurrent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_384solveConcurrent}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_385solveConcurrent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solveConcurrent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("solveConcurrent", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solveConcurrent", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_384solveConcurrent(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_384solveConcurrent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solveConcurrent", 1); + + /* "src/pyscipopt/scip.pxi":3535 + * """Transforms, presolves, and solves problem using additional solvers which emphasize on + * finding solutions.""" + * if SCIPtpiGetNumThreads() == 1: # <<<<<<<<<<<<<< + * warnings.warn("SCIP was compiled without task processing interface. Parallel solve not possible - using optimize() instead of solveConcurrent()") + * self.optimize() + */ + __pyx_t_1 = (SCIPtpiGetNumThreads() == 1); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3536 + * finding solutions.""" + * if SCIPtpiGetNumThreads() == 1: + * warnings.warn("SCIP was compiled without task processing interface. Parallel solve not possible - using optimize() instead of solveConcurrent()") # <<<<<<<<<<<<<< + * self.optimize() + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_warnings); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_warn); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_kp_u_SCIP_was_compiled_without_task_p}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3537 + * if SCIPtpiGetNumThreads() == 1: + * warnings.warn("SCIP was compiled without task processing interface. Parallel solve not possible - using optimize() instead of solveConcurrent()") + * self.optimize() # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPsolveConcurrent(self._scip)) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_optimize); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3535 + * """Transforms, presolves, and solves problem using additional solvers which emphasize on + * finding solutions.""" + * if SCIPtpiGetNumThreads() == 1: # <<<<<<<<<<<<<< + * warnings.warn("SCIP was compiled without task processing interface. Parallel solve not possible - using optimize() instead of solveConcurrent()") + * self.optimize() + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3539 + * self.optimize() + * else: + * PY_SCIP_CALL(SCIPsolveConcurrent(self._scip)) # <<<<<<<<<<<<<< + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsolveConcurrent(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":3540 + * else: + * PY_SCIP_CALL(SCIPsolveConcurrent(self._scip)) + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) # <<<<<<<<<<<<<< + * + * def presolve(self): + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, SCIPgetBestSol(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pyscipopt_4scip_Solution))))) __PYX_ERR(0, 3540, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF((PyObject *)__pyx_v_self->_bestSol); + __Pyx_DECREF((PyObject *)__pyx_v_self->_bestSol); + __pyx_v_self->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_2); + __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3532 + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * + * def solveConcurrent(self): # <<<<<<<<<<<<<< + * """Transforms, presolves, and solves problem using additional solvers which emphasize on + * finding solutions.""" + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.solveConcurrent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3542 + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * + * def presolve(self): # <<<<<<<<<<<<<< + * """Presolve the problem.""" + * PY_SCIP_CALL(SCIPpresolve(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_387presolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_386presolve, "Model.presolve(self)\nPresolve the problem."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_387presolve = {"presolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_387presolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_386presolve}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_387presolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("presolve (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("presolve", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "presolve", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_386presolve(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_386presolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("presolve", 1); + + /* "src/pyscipopt/scip.pxi":3544 + * def presolve(self): + * """Presolve the problem.""" + * PY_SCIP_CALL(SCIPpresolve(self._scip)) # <<<<<<<<<<<<<< + * + * # Benders' decomposition methods + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPpresolve(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3542 + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * + * def presolve(self): # <<<<<<<<<<<<<< + * """Presolve the problem.""" + * PY_SCIP_CALL(SCIPpresolve(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.presolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3547 + * + * # Benders' decomposition methods + * def initBendersDefault(self, subproblems): # <<<<<<<<<<<<<< + * """initialises the default Benders' decomposition with a dictionary of subproblems + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_389initBendersDefault(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_388initBendersDefault, "Model.initBendersDefault(self, subproblems)\ninitialises the default Benders' decomposition with a dictionary of subproblems\n\n Keyword arguments:\n subproblems -- a single Model instance or dictionary of Model instances\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_389initBendersDefault = {"initBendersDefault", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_389initBendersDefault, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_388initBendersDefault}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_389initBendersDefault(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_subproblems = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("initBendersDefault (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_subproblems,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_subproblems)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3547, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "initBendersDefault") < 0)) __PYX_ERR(0, 3547, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_subproblems = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("initBendersDefault", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3547, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.initBendersDefault", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_388initBendersDefault(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_subproblems); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_388initBendersDefault(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_subproblems) { + SCIP **__pyx_v_subprobs; + CYTHON_UNUSED SCIP_BENDERS *__pyx_v_benders; + int __pyx_v_isdict; + PyObject *__pyx_v_nsubproblems = NULL; + PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_subprob = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + SCIP *__pyx_t_10; + Py_ssize_t __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("initBendersDefault", 1); + + /* "src/pyscipopt/scip.pxi":3557 + * + * # checking whether subproblems is a dictionary + * if isinstance(subproblems, dict): # <<<<<<<<<<<<<< + * isdict = True + * nsubproblems = len(subproblems) + */ + __pyx_t_1 = PyDict_Check(__pyx_v_subproblems); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3558 + * # checking whether subproblems is a dictionary + * if isinstance(subproblems, dict): + * isdict = True # <<<<<<<<<<<<<< + * nsubproblems = len(subproblems) + * else: + */ + __pyx_v_isdict = 1; + + /* "src/pyscipopt/scip.pxi":3559 + * if isinstance(subproblems, dict): + * isdict = True + * nsubproblems = len(subproblems) # <<<<<<<<<<<<<< + * else: + * isdict = False + */ + __pyx_t_2 = PyObject_Length(__pyx_v_subproblems); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 3559, __pyx_L1_error) + __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_nsubproblems = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3557 + * + * # checking whether subproblems is a dictionary + * if isinstance(subproblems, dict): # <<<<<<<<<<<<<< + * isdict = True + * nsubproblems = len(subproblems) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3561 + * nsubproblems = len(subproblems) + * else: + * isdict = False # <<<<<<<<<<<<<< + * nsubproblems = 1 + * + */ + /*else*/ { + __pyx_v_isdict = 0; + + /* "src/pyscipopt/scip.pxi":3562 + * else: + * isdict = False + * nsubproblems = 1 # <<<<<<<<<<<<<< + * + * # create array of SCIP instances for the subproblems + */ + __Pyx_INCREF(__pyx_int_1); + __pyx_v_nsubproblems = __pyx_int_1; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3565 + * + * # create array of SCIP instances for the subproblems + * subprobs = malloc(nsubproblems * sizeof(SCIP*)) # <<<<<<<<<<<<<< + * + * # if subproblems is a dictionary, then the dictionary is turned into a c array + */ + __pyx_t_3 = __Pyx_PyInt_FromSize_t((sizeof(SCIP *))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Multiply(__pyx_v_nsubproblems, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3565, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_5 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3565, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_subprobs = ((SCIP **)malloc(__pyx_t_5)); + + /* "src/pyscipopt/scip.pxi":3568 + * + * # if subproblems is a dictionary, then the dictionary is turned into a c array + * if isdict: # <<<<<<<<<<<<<< + * for idx, subprob in enumerate(subproblems.values()): + * subprobs[idx] = (subprob)._scip + */ + if (__pyx_v_isdict) { + + /* "src/pyscipopt/scip.pxi":3569 + * # if subproblems is a dictionary, then the dictionary is turned into a c array + * if isdict: + * for idx, subprob in enumerate(subproblems.values()): # <<<<<<<<<<<<<< + * subprobs[idx] = (subprob)._scip + * else: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_4 = __pyx_int_0; + __pyx_t_2 = 0; + if (unlikely(__pyx_v_subproblems == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); + __PYX_ERR(0, 3569, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_dict_iterator(__pyx_v_subproblems, 0, __pyx_n_s_values, (&__pyx_t_6), (&__pyx_t_7)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_8; + __pyx_t_8 = 0; + while (1) { + __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_6, &__pyx_t_2, NULL, &__pyx_t_8, NULL, __pyx_t_7); + if (unlikely(__pyx_t_9 == 0)) break; + if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 3569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_subprob, __pyx_t_8); + __pyx_t_8 = 0; + __Pyx_INCREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_4, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = __pyx_t_8; + __pyx_t_8 = 0; + + /* "src/pyscipopt/scip.pxi":3570 + * if isdict: + * for idx, subprob in enumerate(subproblems.values()): + * subprobs[idx] = (subprob)._scip # <<<<<<<<<<<<<< + * else: + * subprobs[0] = (subproblems)._scip + */ + __pyx_t_10 = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_subprob)->_scip; + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3570, __pyx_L1_error) + (__pyx_v_subprobs[__pyx_t_11]) = __pyx_t_10; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":3568 + * + * # if subproblems is a dictionary, then the dictionary is turned into a c array + * if isdict: # <<<<<<<<<<<<<< + * for idx, subprob in enumerate(subproblems.values()): + * subprobs[idx] = (subprob)._scip + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3572 + * subprobs[idx] = (subprob)._scip + * else: + * subprobs[0] = (subproblems)._scip # <<<<<<<<<<<<<< + * + * # creating the default Benders' decomposition + */ + /*else*/ { + __pyx_t_10 = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_subproblems)->_scip; + (__pyx_v_subprobs[0]) = __pyx_t_10; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3575 + * + * # creating the default Benders' decomposition + * PY_SCIP_CALL(SCIPcreateBendersDefault(self._scip, subprobs, nsubproblems)) # <<<<<<<<<<<<<< + * benders = SCIPfindBenders(self._scip, "default") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_nsubproblems); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3575, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateBendersDefault(__pyx_v_self->_scip, __pyx_v_subprobs, __pyx_t_7)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_12 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_12)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_8}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":3576 + * # creating the default Benders' decomposition + * PY_SCIP_CALL(SCIPcreateBendersDefault(self._scip, subprobs, nsubproblems)) + * benders = SCIPfindBenders(self._scip, "default") # <<<<<<<<<<<<<< + * + * # activating the Benders' decomposition constraint handlers + */ + __pyx_v_benders = SCIPfindBenders(__pyx_v_self->_scip, ((char const *)"default")); + + /* "src/pyscipopt/scip.pxi":3579 + * + * # activating the Benders' decomposition constraint handlers + * self.setBoolParam("constraints/benderslp/active", True) # <<<<<<<<<<<<<< + * self.setBoolParam("constraints/benders/active", True) + * #self.setIntParam("limits/maxorigsol", 0) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setBoolParam); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__99, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3580 + * # activating the Benders' decomposition constraint handlers + * self.setBoolParam("constraints/benderslp/active", True) + * self.setBoolParam("constraints/benders/active", True) # <<<<<<<<<<<<<< + * #self.setIntParam("limits/maxorigsol", 0) + * + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setBoolParam); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__100, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":3547 + * + * # Benders' decomposition methods + * def initBendersDefault(self, subproblems): # <<<<<<<<<<<<<< + * """initialises the default Benders' decomposition with a dictionary of subproblems + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("pyscipopt.scip.Model.initBendersDefault", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nsubproblems); + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_subprob); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3583 + * #self.setIntParam("limits/maxorigsol", 0) + * + * def computeBestSolSubproblems(self): # <<<<<<<<<<<<<< + * """Solves the subproblems with the best solution to the master problem. + * Afterwards, the best solution from each subproblem can be queried to get + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_391computeBestSolSubproblems(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_390computeBestSolSubproblems, "Model.computeBestSolSubproblems(self)\nSolves the subproblems with the best solution to the master problem.\n Afterwards, the best solution from each subproblem can be queried to get\n the solution to the original problem.\n\n If the user wants to resolve the subproblems, they must free them by\n calling freeBendersSubproblems()\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_391computeBestSolSubproblems = {"computeBestSolSubproblems", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_391computeBestSolSubproblems, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_390computeBestSolSubproblems}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_391computeBestSolSubproblems(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("computeBestSolSubproblems (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("computeBestSolSubproblems", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "computeBestSolSubproblems", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_390computeBestSolSubproblems(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_390computeBestSolSubproblems(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_BENDERS **__pyx_v__benders; + SCIP_Bool __pyx_v__infeasible; + int __pyx_v_nbenders; + int __pyx_v_nsubproblems; + int __pyx_v_solvecip; + int __pyx_v_i; + int __pyx_v_j; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("computeBestSolSubproblems", 1); + + /* "src/pyscipopt/scip.pxi":3596 + * cdef int nsubproblems + * + * solvecip = True # <<<<<<<<<<<<<< + * + * nbenders = SCIPgetNActiveBenders(self._scip) + */ + __pyx_v_solvecip = 1; + + /* "src/pyscipopt/scip.pxi":3598 + * solvecip = True + * + * nbenders = SCIPgetNActiveBenders(self._scip) # <<<<<<<<<<<<<< + * _benders = SCIPgetBenders(self._scip) + * + */ + __pyx_v_nbenders = SCIPgetNActiveBenders(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":3599 + * + * nbenders = SCIPgetNActiveBenders(self._scip) + * _benders = SCIPgetBenders(self._scip) # <<<<<<<<<<<<<< + * + * # solving all subproblems from all Benders' decompositions + */ + __pyx_v__benders = SCIPgetBenders(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":3602 + * + * # solving all subproblems from all Benders' decompositions + * for i in range(nbenders): # <<<<<<<<<<<<<< + * nsubproblems = SCIPbendersGetNSubproblems(_benders[i]) + * for j in range(nsubproblems): + */ + __pyx_t_1 = __pyx_v_nbenders; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "src/pyscipopt/scip.pxi":3603 + * # solving all subproblems from all Benders' decompositions + * for i in range(nbenders): + * nsubproblems = SCIPbendersGetNSubproblems(_benders[i]) # <<<<<<<<<<<<<< + * for j in range(nsubproblems): + * PY_SCIP_CALL(SCIPsetupBendersSubproblem(self._scip, + */ + __pyx_v_nsubproblems = SCIPbendersGetNSubproblems((__pyx_v__benders[__pyx_v_i])); + + /* "src/pyscipopt/scip.pxi":3604 + * for i in range(nbenders): + * nsubproblems = SCIPbendersGetNSubproblems(_benders[i]) + * for j in range(nsubproblems): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetupBendersSubproblem(self._scip, + * _benders[i], self._bestSol.sol, j, SCIP_BENDERSENFOTYPE_CHECK)) + */ + __pyx_t_4 = __pyx_v_nsubproblems; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_j = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":3605 + * nsubproblems = SCIPbendersGetNSubproblems(_benders[i]) + * for j in range(nsubproblems): + * PY_SCIP_CALL(SCIPsetupBendersSubproblem(self._scip, # <<<<<<<<<<<<<< + * _benders[i], self._bestSol.sol, j, SCIP_BENDERSENFOTYPE_CHECK)) + * PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "src/pyscipopt/scip.pxi":3606 + * for j in range(nsubproblems): + * PY_SCIP_CALL(SCIPsetupBendersSubproblem(self._scip, + * _benders[i], self._bestSol.sol, j, SCIP_BENDERSENFOTYPE_CHECK)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, + * _benders[i], self._bestSol.sol, j, &_infeasible, solvecip, NULL)) + */ + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetupBendersSubproblem(__pyx_v_self->_scip, (__pyx_v__benders[__pyx_v_i]), __pyx_v_self->_bestSol->sol, __pyx_v_j, SCIP_BENDERSENFOTYPE_CHECK)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":3607 + * PY_SCIP_CALL(SCIPsetupBendersSubproblem(self._scip, + * _benders[i], self._bestSol.sol, j, SCIP_BENDERSENFOTYPE_CHECK)) + * PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, # <<<<<<<<<<<<<< + * _benders[i], self._bestSol.sol, j, &_infeasible, solvecip, NULL)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "src/pyscipopt/scip.pxi":3608 + * _benders[i], self._bestSol.sol, j, SCIP_BENDERSENFOTYPE_CHECK)) + * PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, + * _benders[i], self._bestSol.sol, j, &_infeasible, solvecip, NULL)) # <<<<<<<<<<<<<< + * + * def freeBendersSubproblems(self): + */ + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsolveBendersSubproblem(__pyx_v_self->_scip, (__pyx_v__benders[__pyx_v_i]), __pyx_v_self->_bestSol->sol, __pyx_v_j, (&__pyx_v__infeasible), __pyx_v_solvecip, NULL)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + + /* "src/pyscipopt/scip.pxi":3583 + * #self.setIntParam("limits/maxorigsol", 0) + * + * def computeBestSolSubproblems(self): # <<<<<<<<<<<<<< + * """Solves the subproblems with the best solution to the master problem. + * Afterwards, the best solution from each subproblem can be queried to get + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pyscipopt.scip.Model.computeBestSolSubproblems", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3610 + * _benders[i], self._bestSol.sol, j, &_infeasible, solvecip, NULL)) + * + * def freeBendersSubproblems(self): # <<<<<<<<<<<<<< + * """Calls the free subproblem function for the Benders' decomposition. + * This will free all subproblems for all decompositions. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_393freeBendersSubproblems(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_392freeBendersSubproblems, "Model.freeBendersSubproblems(self)\nCalls the free subproblem function for the Benders' decomposition.\n This will free all subproblems for all decompositions.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_393freeBendersSubproblems = {"freeBendersSubproblems", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_393freeBendersSubproblems, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_392freeBendersSubproblems}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_393freeBendersSubproblems(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("freeBendersSubproblems (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("freeBendersSubproblems", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "freeBendersSubproblems", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_392freeBendersSubproblems(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_392freeBendersSubproblems(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_BENDERS **__pyx_v__benders; + int __pyx_v_nbenders; + int __pyx_v_nsubproblems; + int __pyx_v_i; + int __pyx_v_j; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("freeBendersSubproblems", 1); + + /* "src/pyscipopt/scip.pxi":3618 + * cdef int nsubproblems + * + * nbenders = SCIPgetNActiveBenders(self._scip) # <<<<<<<<<<<<<< + * _benders = SCIPgetBenders(self._scip) + * + */ + __pyx_v_nbenders = SCIPgetNActiveBenders(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":3619 + * + * nbenders = SCIPgetNActiveBenders(self._scip) + * _benders = SCIPgetBenders(self._scip) # <<<<<<<<<<<<<< + * + * # solving all subproblems from all Benders' decompositions + */ + __pyx_v__benders = SCIPgetBenders(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":3622 + * + * # solving all subproblems from all Benders' decompositions + * for i in range(nbenders): # <<<<<<<<<<<<<< + * nsubproblems = SCIPbendersGetNSubproblems(_benders[i]) + * for j in range(nsubproblems): + */ + __pyx_t_1 = __pyx_v_nbenders; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "src/pyscipopt/scip.pxi":3623 + * # solving all subproblems from all Benders' decompositions + * for i in range(nbenders): + * nsubproblems = SCIPbendersGetNSubproblems(_benders[i]) # <<<<<<<<<<<<<< + * for j in range(nsubproblems): + * PY_SCIP_CALL(SCIPfreeBendersSubproblem(self._scip, _benders[i], + */ + __pyx_v_nsubproblems = SCIPbendersGetNSubproblems((__pyx_v__benders[__pyx_v_i])); + + /* "src/pyscipopt/scip.pxi":3624 + * for i in range(nbenders): + * nsubproblems = SCIPbendersGetNSubproblems(_benders[i]) + * for j in range(nsubproblems): # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPfreeBendersSubproblem(self._scip, _benders[i], + * j)) + */ + __pyx_t_4 = __pyx_v_nsubproblems; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_j = __pyx_t_6; + + /* "src/pyscipopt/scip.pxi":3625 + * nsubproblems = SCIPbendersGetNSubproblems(_benders[i]) + * for j in range(nsubproblems): + * PY_SCIP_CALL(SCIPfreeBendersSubproblem(self._scip, _benders[i], # <<<<<<<<<<<<<< + * j)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "src/pyscipopt/scip.pxi":3626 + * for j in range(nsubproblems): + * PY_SCIP_CALL(SCIPfreeBendersSubproblem(self._scip, _benders[i], + * j)) # <<<<<<<<<<<<<< + * + * def updateBendersLowerbounds(self, lowerbounds, Benders benders=None): + */ + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPfreeBendersSubproblem(__pyx_v_self->_scip, (__pyx_v__benders[__pyx_v_i]), __pyx_v_j)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_8, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_8, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + } + + /* "src/pyscipopt/scip.pxi":3610 + * _benders[i], self._bestSol.sol, j, &_infeasible, solvecip, NULL)) + * + * def freeBendersSubproblems(self): # <<<<<<<<<<<<<< + * """Calls the free subproblem function for the Benders' decomposition. + * This will free all subproblems for all decompositions. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pyscipopt.scip.Model.freeBendersSubproblems", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3628 + * j)) + * + * def updateBendersLowerbounds(self, lowerbounds, Benders benders=None): # <<<<<<<<<<<<<< + * """"updates the subproblem lower bounds for benders using + * the lowerbounds dict. If benders is None, then the default + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_395updateBendersLowerbounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_394updateBendersLowerbounds, "Model.updateBendersLowerbounds(self, lowerbounds, Benders benders=None)\n\"updates the subproblem lower bounds for benders using\n the lowerbounds dict. If benders is None, then the default\n Benders' decomposition is updated\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_395updateBendersLowerbounds = {"updateBendersLowerbounds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_395updateBendersLowerbounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_394updateBendersLowerbounds}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_395updateBendersLowerbounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_lowerbounds = 0; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("updateBendersLowerbounds (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_lowerbounds,&__pyx_n_s_benders,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lowerbounds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3628, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3628, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "updateBendersLowerbounds") < 0)) __PYX_ERR(0, 3628, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_lowerbounds = values[0]; + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("updateBendersLowerbounds", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3628, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.updateBendersLowerbounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3628, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_394updateBendersLowerbounds(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_lowerbounds, __pyx_v_benders); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_394updateBendersLowerbounds(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_lowerbounds, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders) { + SCIP_BENDERS *__pyx_v__benders; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_BENDERS *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + SCIP_Real __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("updateBendersLowerbounds", 1); + + /* "src/pyscipopt/scip.pxi":3635 + * cdef SCIP_BENDERS* _benders + * + * assert type(lowerbounds) is dict # <<<<<<<<<<<<<< + * + * if benders is None: + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (((PyObject *)Py_TYPE(__pyx_v_lowerbounds)) == ((PyObject *)(&PyDict_Type))); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 3635, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 3635, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":3637 + * assert type(lowerbounds) is dict + * + * if benders is None: # <<<<<<<<<<<<<< + * _benders = SCIPfindBenders(self._scip, "default") + * else: + */ + __pyx_t_1 = (((PyObject *)__pyx_v_benders) == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3638 + * + * if benders is None: + * _benders = SCIPfindBenders(self._scip, "default") # <<<<<<<<<<<<<< + * else: + * _benders = benders._benders + */ + __pyx_v__benders = SCIPfindBenders(__pyx_v_self->_scip, ((char const *)"default")); + + /* "src/pyscipopt/scip.pxi":3637 + * assert type(lowerbounds) is dict + * + * if benders is None: # <<<<<<<<<<<<<< + * _benders = SCIPfindBenders(self._scip, "default") + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3640 + * _benders = SCIPfindBenders(self._scip, "default") + * else: + * _benders = benders._benders # <<<<<<<<<<<<<< + * + * for d in lowerbounds.keys(): + */ + /*else*/ { + __pyx_t_2 = __pyx_v_benders->_benders; + __pyx_v__benders = __pyx_t_2; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3642 + * _benders = benders._benders + * + * for d in lowerbounds.keys(): # <<<<<<<<<<<<<< + * SCIPbendersUpdateSubproblemLowerbound(_benders, d, lowerbounds[d]) + * + */ + __pyx_t_4 = 0; + if (unlikely(__pyx_v_lowerbounds == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 3642, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_dict_iterator(__pyx_v_lowerbounds, 0, __pyx_n_s_keys, (&__pyx_t_5), (&__pyx_t_6)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + while (1) { + __pyx_t_8 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_5, &__pyx_t_4, &__pyx_t_7, NULL, NULL, __pyx_t_6); + if (unlikely(__pyx_t_8 == 0)) break; + if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 3642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_v_d, __pyx_t_7); + __pyx_t_7 = 0; + + /* "src/pyscipopt/scip.pxi":3643 + * + * for d in lowerbounds.keys(): + * SCIPbendersUpdateSubproblemLowerbound(_benders, d, lowerbounds[d]) # <<<<<<<<<<<<<< + * + * def activateBenders(self, Benders benders, int nsubproblems): + */ + __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_d); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3643, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_lowerbounds, __pyx_v_d); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = __pyx_PyFloat_AsDouble(__pyx_t_7); if (unlikely((__pyx_t_9 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3643, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + SCIPbendersUpdateSubproblemLowerbound(__pyx_v__benders, __pyx_t_8, __pyx_t_9); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3628 + * j)) + * + * def updateBendersLowerbounds(self, lowerbounds, Benders benders=None): # <<<<<<<<<<<<<< + * """"updates the subproblem lower bounds for benders using + * the lowerbounds dict. If benders is None, then the default + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.updateBendersLowerbounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3645 + * SCIPbendersUpdateSubproblemLowerbound(_benders, d, lowerbounds[d]) + * + * def activateBenders(self, Benders benders, int nsubproblems): # <<<<<<<<<<<<<< + * """Activates the Benders' decomposition plugin with the input name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_397activateBenders(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_396activateBenders, "Model.activateBenders(self, Benders benders, int nsubproblems)\nActivates the Benders' decomposition plugin with the input name\n\n Keyword arguments:\n benders -- the Benders' decomposition to which the subproblem belongs to\n nsubproblems -- the number of subproblems in the Benders' decomposition\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_397activateBenders = {"activateBenders", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_397activateBenders, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_396activateBenders}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_397activateBenders(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + int __pyx_v_nsubproblems; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("activateBenders (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_benders,&__pyx_n_s_nsubproblems,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3645, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nsubproblems)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3645, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("activateBenders", 1, 2, 2, 1); __PYX_ERR(0, 3645, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "activateBenders") < 0)) __PYX_ERR(0, 3645, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[0]); + __pyx_v_nsubproblems = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_nsubproblems == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3645, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("activateBenders", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3645, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.activateBenders", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3645, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_396activateBenders(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_benders, __pyx_v_nsubproblems); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_396activateBenders(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, int __pyx_v_nsubproblems) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("activateBenders", 1); + + /* "src/pyscipopt/scip.pxi":3652 + * nsubproblems -- the number of subproblems in the Benders' decomposition + * """ + * PY_SCIP_CALL(SCIPactivateBenders(self._scip, benders._benders, nsubproblems)) # <<<<<<<<<<<<<< + * + * def addBendersSubproblem(self, Benders benders, subproblem): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPactivateBenders(__pyx_v_self->_scip, __pyx_v_benders->_benders, __pyx_v_nsubproblems)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3645 + * SCIPbendersUpdateSubproblemLowerbound(_benders, d, lowerbounds[d]) + * + * def activateBenders(self, Benders benders, int nsubproblems): # <<<<<<<<<<<<<< + * """Activates the Benders' decomposition plugin with the input name + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.activateBenders", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3654 + * PY_SCIP_CALL(SCIPactivateBenders(self._scip, benders._benders, nsubproblems)) + * + * def addBendersSubproblem(self, Benders benders, subproblem): # <<<<<<<<<<<<<< + * """adds a subproblem to the Benders' decomposition given by the input + * name. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_399addBendersSubproblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_398addBendersSubproblem, "Model.addBendersSubproblem(self, Benders benders, subproblem)\nadds a subproblem to the Benders' decomposition given by the input\n name.\n\n Keyword arguments:\n benders -- the Benders' decomposition to which the subproblem belongs to\n subproblem -- the subproblem to add to the decomposition\n isconvex -- can be used to specify whether the subproblem is convex\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_399addBendersSubproblem = {"addBendersSubproblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_399addBendersSubproblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_398addBendersSubproblem}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_399addBendersSubproblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + PyObject *__pyx_v_subproblem = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addBendersSubproblem (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_benders,&__pyx_n_s_subproblem,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3654, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_subproblem)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3654, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("addBendersSubproblem", 1, 2, 2, 1); __PYX_ERR(0, 3654, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addBendersSubproblem") < 0)) __PYX_ERR(0, 3654, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[0]); + __pyx_v_subproblem = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addBendersSubproblem", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3654, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addBendersSubproblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3654, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_398addBendersSubproblem(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_benders, __pyx_v_subproblem); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_398addBendersSubproblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, PyObject *__pyx_v_subproblem) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addBendersSubproblem", 1); + + /* "src/pyscipopt/scip.pxi":3663 + * isconvex -- can be used to specify whether the subproblem is convex + * """ + * PY_SCIP_CALL(SCIPaddBendersSubproblem(self._scip, benders._benders, (subproblem)._scip)) # <<<<<<<<<<<<<< + * + * def setBendersSubproblemIsConvex(self, Benders benders, probnumber, isconvex = True): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddBendersSubproblem(__pyx_v_self->_scip, __pyx_v_benders->_benders, ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_subproblem)->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3654 + * PY_SCIP_CALL(SCIPactivateBenders(self._scip, benders._benders, nsubproblems)) + * + * def addBendersSubproblem(self, Benders benders, subproblem): # <<<<<<<<<<<<<< + * """adds a subproblem to the Benders' decomposition given by the input + * name. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.addBendersSubproblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3665 + * PY_SCIP_CALL(SCIPaddBendersSubproblem(self._scip, benders._benders, (subproblem)._scip)) + * + * def setBendersSubproblemIsConvex(self, Benders benders, probnumber, isconvex = True): # <<<<<<<<<<<<<< + * """sets a flag indicating whether the subproblem is convex + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_401setBendersSubproblemIsConvex(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_400setBendersSubproblemIsConvex, "Model.setBendersSubproblemIsConvex(self, Benders benders, probnumber, isconvex=True)\nsets a flag indicating whether the subproblem is convex\n\n Keyword arguments:\n benders -- the Benders' decomposition which contains the subproblem\n probnumber -- the problem number of the subproblem that the convexity will be set for\n isconvex -- flag to indicate whether the subproblem is convex\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_401setBendersSubproblemIsConvex = {"setBendersSubproblemIsConvex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_401setBendersSubproblemIsConvex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_400setBendersSubproblemIsConvex}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_401setBendersSubproblemIsConvex(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + PyObject *__pyx_v_probnumber = 0; + PyObject *__pyx_v_isconvex = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setBendersSubproblemIsConvex (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_benders,&__pyx_n_s_probnumber,&__pyx_n_s_isconvex,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3665, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3665, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setBendersSubproblemIsConvex", 0, 2, 3, 1); __PYX_ERR(0, 3665, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_isconvex); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3665, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setBendersSubproblemIsConvex") < 0)) __PYX_ERR(0, 3665, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[0]); + __pyx_v_probnumber = values[1]; + __pyx_v_isconvex = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setBendersSubproblemIsConvex", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 3665, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setBendersSubproblemIsConvex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3665, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_400setBendersSubproblemIsConvex(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_benders, __pyx_v_probnumber, __pyx_v_isconvex); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_400setBendersSubproblemIsConvex(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, PyObject *__pyx_v_probnumber, PyObject *__pyx_v_isconvex) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_Bool __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setBendersSubproblemIsConvex", 1); + + /* "src/pyscipopt/scip.pxi":3673 + * isconvex -- flag to indicate whether the subproblem is convex + * """ + * SCIPbendersSetSubproblemIsConvex(benders._benders, probnumber, isconvex) # <<<<<<<<<<<<<< + * + * def setupBendersSubproblem(self, probnumber, Benders benders = None, Solution solution = None, checktype = PY_SCIP_BENDERSENFOTYPE.LP): + */ + __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_probnumber); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3673, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_isconvex); if (unlikely((__pyx_t_2 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3673, __pyx_L1_error) + SCIPbendersSetSubproblemIsConvex(__pyx_v_benders->_benders, __pyx_t_1, __pyx_t_2); + + /* "src/pyscipopt/scip.pxi":3665 + * PY_SCIP_CALL(SCIPaddBendersSubproblem(self._scip, benders._benders, (subproblem)._scip)) + * + * def setBendersSubproblemIsConvex(self, Benders benders, probnumber, isconvex = True): # <<<<<<<<<<<<<< + * """sets a flag indicating whether the subproblem is convex + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Model.setBendersSubproblemIsConvex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3675 + * SCIPbendersSetSubproblemIsConvex(benders._benders, probnumber, isconvex) + * + * def setupBendersSubproblem(self, probnumber, Benders benders = None, Solution solution = None, checktype = PY_SCIP_BENDERSENFOTYPE.LP): # <<<<<<<<<<<<<< + * """ sets up the Benders' subproblem given the master problem solution + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_403setupBendersSubproblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_402setupBendersSubproblem, "Model.setupBendersSubproblem(self, probnumber, Benders benders=None, Solution solution=None, checktype=PY_SCIP_BENDERSENFOTYPE.LP)\n sets up the Benders' subproblem given the master problem solution\n\n Keyword arguments:\n probnumber -- the index of the problem that is to be set up\n benders -- the Benders' decomposition to which the subproblem belongs to\n solution -- the master problem solution that is used for the set up, if None, then the LP solution is used\n checktype -- the type of solution check that prompted the solving of the Benders' subproblems, either\n PY_SCIP_BENDERSENFOTYPE: LP, RELAX, PSEUDO or CHECK. Default is LP\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_403setupBendersSubproblem = {"setupBendersSubproblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_403setupBendersSubproblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_402setupBendersSubproblem}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_403setupBendersSubproblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_probnumber = 0; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_checktype = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setupBendersSubproblem (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_probnumber,&__pyx_n_s_benders,&__pyx_n_s_solution,&__pyx_n_s_checktype,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None)); + values[2] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(__pyx_k__101); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3675, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3675, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3675, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checktype); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3675, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setupBendersSubproblem") < 0)) __PYX_ERR(0, 3675, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_probnumber = values[0]; + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[1]); + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[2]); + __pyx_v_checktype = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setupBendersSubproblem", 0, 1, 4, __pyx_nargs); __PYX_ERR(0, 3675, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setupBendersSubproblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3675, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 3675, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_402setupBendersSubproblem(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_probnumber, __pyx_v_benders, __pyx_v_solution, __pyx_v_checktype); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_402setupBendersSubproblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probnumber, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_checktype) { + SCIP_BENDERS *__pyx_v_scip_benders; + SCIP_SOL *__pyx_v_scip_sol; + SCIP_RETCODE __pyx_v_retcode; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_SOL *__pyx_t_2; + SCIP_BENDERS *__pyx_t_3; + int __pyx_t_4; + SCIP_BENDERSENFOTYPE __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setupBendersSubproblem", 1); + + /* "src/pyscipopt/scip.pxi":3688 + * cdef SCIP_SOL* scip_sol + * + * if isinstance(solution, Solution): # <<<<<<<<<<<<<< + * scip_sol = solution.sol + * else: + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3689 + * + * if isinstance(solution, Solution): + * scip_sol = solution.sol # <<<<<<<<<<<<<< + * else: + * scip_sol = NULL + */ + __pyx_t_2 = __pyx_v_solution->sol; + __pyx_v_scip_sol = __pyx_t_2; + + /* "src/pyscipopt/scip.pxi":3688 + * cdef SCIP_SOL* scip_sol + * + * if isinstance(solution, Solution): # <<<<<<<<<<<<<< + * scip_sol = solution.sol + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3691 + * scip_sol = solution.sol + * else: + * scip_sol = NULL # <<<<<<<<<<<<<< + * + * if benders is None: + */ + /*else*/ { + __pyx_v_scip_sol = NULL; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3693 + * scip_sol = NULL + * + * if benders is None: # <<<<<<<<<<<<<< + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + */ + __pyx_t_1 = (((PyObject *)__pyx_v_benders) == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3694 + * + * if benders is None: + * scip_benders = SCIPfindBenders(self._scip, "default") # <<<<<<<<<<<<<< + * else: + * scip_benders = benders._benders + */ + __pyx_v_scip_benders = SCIPfindBenders(__pyx_v_self->_scip, ((char const *)"default")); + + /* "src/pyscipopt/scip.pxi":3693 + * scip_sol = NULL + * + * if benders is None: # <<<<<<<<<<<<<< + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3696 + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + * scip_benders = benders._benders # <<<<<<<<<<<<<< + * + * retcode = SCIPsetupBendersSubproblem(self._scip, scip_benders, scip_sol, probnumber, checktype) + */ + /*else*/ { + __pyx_t_3 = __pyx_v_benders->_benders; + __pyx_v_scip_benders = __pyx_t_3; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3698 + * scip_benders = benders._benders + * + * retcode = SCIPsetupBendersSubproblem(self._scip, scip_benders, scip_sol, probnumber, checktype) # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(retcode) + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_probnumber); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3698, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_As_SCIP_BENDERSENFOTYPE(__pyx_v_checktype); if (unlikely((__pyx_t_5 == ((SCIP_BENDERSENFOTYPE)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3698, __pyx_L1_error) + __pyx_v_retcode = SCIPsetupBendersSubproblem(__pyx_v_self->_scip, __pyx_v_scip_benders, __pyx_v_scip_sol, __pyx_t_4, __pyx_t_5); + + /* "src/pyscipopt/scip.pxi":3700 + * retcode = SCIPsetupBendersSubproblem(self._scip, scip_benders, scip_sol, probnumber, checktype) + * + * PY_SCIP_CALL(retcode) # <<<<<<<<<<<<<< + * + * def solveBendersSubproblem(self, probnumber, solvecip, Benders benders = None, Solution solution = None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(__pyx_v_retcode); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_8}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":3675 + * SCIPbendersSetSubproblemIsConvex(benders._benders, probnumber, isconvex) + * + * def setupBendersSubproblem(self, probnumber, Benders benders = None, Solution solution = None, checktype = PY_SCIP_BENDERSENFOTYPE.LP): # <<<<<<<<<<<<<< + * """ sets up the Benders' subproblem given the master problem solution + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.setupBendersSubproblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3702 + * PY_SCIP_CALL(retcode) + * + * def solveBendersSubproblem(self, probnumber, solvecip, Benders benders = None, Solution solution = None): # <<<<<<<<<<<<<< + * """ solves the Benders' decomposition subproblem. The convex relaxation will be solved unless + * the parameter solvecip is set to True. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_405solveBendersSubproblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_404solveBendersSubproblem, "Model.solveBendersSubproblem(self, probnumber, solvecip, Benders benders=None, Solution solution=None)\n solves the Benders' decomposition subproblem. The convex relaxation will be solved unless\n the parameter solvecip is set to True.\n\n Keyword arguments:\n probnumber -- the index of the problem that is to be set up\n solvecip -- should the CIP of the subproblem be solved, if False, then only the convex relaxation is solved\n benders -- the Benders' decomposition to which the subproblem belongs to\n solution -- the master problem solution that is used for the set up, if None, then the LP solution is used\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_405solveBendersSubproblem = {"solveBendersSubproblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_405solveBendersSubproblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_404solveBendersSubproblem}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_405solveBendersSubproblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_probnumber = 0; + PyObject *__pyx_v_solvecip = 0; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solveBendersSubproblem (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_probnumber,&__pyx_n_s_solvecip,&__pyx_n_s_benders,&__pyx_n_s_solution,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None)); + values[3] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3702, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solvecip)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3702, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("solveBendersSubproblem", 0, 2, 4, 1); __PYX_ERR(0, 3702, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3702, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3702, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "solveBendersSubproblem") < 0)) __PYX_ERR(0, 3702, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_probnumber = values[0]; + __pyx_v_solvecip = values[1]; + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[2]); + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("solveBendersSubproblem", 0, 2, 4, __pyx_nargs); __PYX_ERR(0, 3702, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.solveBendersSubproblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3702, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 3702, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_404solveBendersSubproblem(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_probnumber, __pyx_v_solvecip, __pyx_v_benders, __pyx_v_solution); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_404solveBendersSubproblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probnumber, PyObject *__pyx_v_solvecip, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution) { + SCIP_BENDERS *__pyx_v_scip_benders; + SCIP_SOL *__pyx_v_scip_sol; + SCIP_Real __pyx_v_objective; + SCIP_Bool __pyx_v_infeasible; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_SOL *__pyx_t_2; + SCIP_BENDERS *__pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + SCIP_Bool __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solveBendersSubproblem", 1); + + /* "src/pyscipopt/scip.pxi":3718 + * cdef SCIP_Bool infeasible + * + * if isinstance(solution, Solution): # <<<<<<<<<<<<<< + * scip_sol = solution.sol + * else: + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3719 + * + * if isinstance(solution, Solution): + * scip_sol = solution.sol # <<<<<<<<<<<<<< + * else: + * scip_sol = NULL + */ + __pyx_t_2 = __pyx_v_solution->sol; + __pyx_v_scip_sol = __pyx_t_2; + + /* "src/pyscipopt/scip.pxi":3718 + * cdef SCIP_Bool infeasible + * + * if isinstance(solution, Solution): # <<<<<<<<<<<<<< + * scip_sol = solution.sol + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3721 + * scip_sol = solution.sol + * else: + * scip_sol = NULL # <<<<<<<<<<<<<< + * + * if benders is None: + */ + /*else*/ { + __pyx_v_scip_sol = NULL; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3723 + * scip_sol = NULL + * + * if benders is None: # <<<<<<<<<<<<<< + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + */ + __pyx_t_1 = (((PyObject *)__pyx_v_benders) == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3724 + * + * if benders is None: + * scip_benders = SCIPfindBenders(self._scip, "default") # <<<<<<<<<<<<<< + * else: + * scip_benders = benders._benders + */ + __pyx_v_scip_benders = SCIPfindBenders(__pyx_v_self->_scip, ((char const *)"default")); + + /* "src/pyscipopt/scip.pxi":3723 + * scip_sol = NULL + * + * if benders is None: # <<<<<<<<<<<<<< + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3726 + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + * scip_benders = benders._benders # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, scip_benders, scip_sol, + */ + /*else*/ { + __pyx_t_3 = __pyx_v_benders->_benders; + __pyx_v_scip_benders = __pyx_t_3; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3728 + * scip_benders = benders._benders + * + * PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, scip_benders, scip_sol, # <<<<<<<<<<<<<< + * probnumber, &infeasible, solvecip, &objective)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "src/pyscipopt/scip.pxi":3729 + * + * PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, scip_benders, scip_sol, + * probnumber, &infeasible, solvecip, &objective)) # <<<<<<<<<<<<<< + * + * return infeasible, objective + */ + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_probnumber); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3729, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_solvecip); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3729, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3728 + * scip_benders = benders._benders + * + * PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, scip_benders, scip_sol, # <<<<<<<<<<<<<< + * probnumber, &infeasible, solvecip, &objective)) + * + */ + __pyx_t_8 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsolveBendersSubproblem(__pyx_v_self->_scip, __pyx_v_scip_benders, __pyx_v_scip_sol, __pyx_t_6, (&__pyx_v_infeasible), __pyx_t_7, (&__pyx_v_objective))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_8}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3728, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":3731 + * probnumber, &infeasible, solvecip, &objective)) + * + * return infeasible, objective # <<<<<<<<<<<<<< + * + * def getBendersSubproblem(self, probnumber, Benders benders = None): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_infeasible); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3731, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_objective); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3731, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3731, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4)) __PYX_ERR(0, 3731, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_5)) __PYX_ERR(0, 3731, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_8; + __pyx_t_8 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3702 + * PY_SCIP_CALL(retcode) + * + * def solveBendersSubproblem(self, probnumber, solvecip, Benders benders = None, Solution solution = None): # <<<<<<<<<<<<<< + * """ solves the Benders' decomposition subproblem. The convex relaxation will be solved unless + * the parameter solvecip is set to True. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.solveBendersSubproblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3733 + * return infeasible, objective + * + * def getBendersSubproblem(self, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns a Model object that wraps around the SCIP instance of the subproblem. + * NOTE: This Model object is just a place holder and SCIP instance will not be freed when the object is destroyed. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_407getBendersSubproblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_406getBendersSubproblem, "Model.getBendersSubproblem(self, probnumber, Benders benders=None)\nReturns a Model object that wraps around the SCIP instance of the subproblem.\n NOTE: This Model object is just a place holder and SCIP instance will not be freed when the object is destroyed.\n\n Keyword arguments:\n probnumber -- the problem number for subproblem that is required\n benders -- the Benders' decomposition object for the that the subproblem belongs to (Default = None)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_407getBendersSubproblem = {"getBendersSubproblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_407getBendersSubproblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_406getBendersSubproblem}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_407getBendersSubproblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_probnumber = 0; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBendersSubproblem (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_probnumber,&__pyx_n_s_benders,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3733, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3733, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getBendersSubproblem") < 0)) __PYX_ERR(0, 3733, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_probnumber = values[0]; + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getBendersSubproblem", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3733, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getBendersSubproblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3733, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_406getBendersSubproblem(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_probnumber, __pyx_v_benders); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_406getBendersSubproblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probnumber, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders) { + SCIP_BENDERS *__pyx_v_scip_benders; + SCIP *__pyx_v_scip_subprob; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_BENDERS *__pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBendersSubproblem", 1); + + /* "src/pyscipopt/scip.pxi":3744 + * cdef SCIP* scip_subprob + * + * if benders is None: # <<<<<<<<<<<<<< + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + */ + __pyx_t_1 = (((PyObject *)__pyx_v_benders) == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3745 + * + * if benders is None: + * scip_benders = SCIPfindBenders(self._scip, "default") # <<<<<<<<<<<<<< + * else: + * scip_benders = benders._benders + */ + __pyx_v_scip_benders = SCIPfindBenders(__pyx_v_self->_scip, ((char const *)"default")); + + /* "src/pyscipopt/scip.pxi":3744 + * cdef SCIP* scip_subprob + * + * if benders is None: # <<<<<<<<<<<<<< + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3747 + * scip_benders = SCIPfindBenders(self._scip, "default") + * else: + * scip_benders = benders._benders # <<<<<<<<<<<<<< + * + * scip_subprob = SCIPbendersSubproblem(scip_benders, probnumber) + */ + /*else*/ { + __pyx_t_2 = __pyx_v_benders->_benders; + __pyx_v_scip_benders = __pyx_t_2; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3749 + * scip_benders = benders._benders + * + * scip_subprob = SCIPbendersSubproblem(scip_benders, probnumber) # <<<<<<<<<<<<<< + * + * return Model.create(scip_subprob) + */ + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_probnumber); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3749, __pyx_L1_error) + __pyx_v_scip_subprob = SCIPbendersSubproblem(__pyx_v_scip_benders, __pyx_t_3); + + /* "src/pyscipopt/scip.pxi":3751 + * scip_subprob = SCIPbendersSubproblem(scip_benders, probnumber) + * + * return Model.create(scip_subprob) # <<<<<<<<<<<<<< + * + * def getBendersVar(self, Variable var, Benders benders = None, probnumber = -1): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __pyx_f_9pyscipopt_4scip_5Model_create(__pyx_v_scip_subprob); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3751, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3733 + * return infeasible, objective + * + * def getBendersSubproblem(self, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns a Model object that wraps around the SCIP instance of the subproblem. + * NOTE: This Model object is just a place holder and SCIP instance will not be freed when the object is destroyed. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBendersSubproblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3753 + * return Model.create(scip_subprob) + * + * def getBendersVar(self, Variable var, Benders benders = None, probnumber = -1): # <<<<<<<<<<<<<< + * """Returns the variable for the subproblem or master problem + * depending on the input probnumber + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_409getBendersVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_408getBendersVar, "Model.getBendersVar(self, Variable var, Benders benders=None, probnumber=-1)\nReturns the variable for the subproblem or master problem\n depending on the input probnumber\n\n Keyword arguments:\n var -- the source variable for which the target variable is requested\n benders -- the Benders' decomposition to which the subproblem variables belong to\n probnumber -- the problem number for which the target variable belongs, -1 for master problem\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_409getBendersVar = {"getBendersVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_409getBendersVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_408getBendersVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_409getBendersVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + PyObject *__pyx_v_probnumber = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBendersVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_benders,&__pyx_n_s_probnumber,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_neg_1)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3753, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3753, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3753, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getBendersVar") < 0)) __PYX_ERR(0, 3753, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[1]); + __pyx_v_probnumber = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getBendersVar", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 3753, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getBendersVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 3753, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3753, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_408getBendersVar(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_benders, __pyx_v_probnumber); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_408getBendersVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, PyObject *__pyx_v_probnumber) { + SCIP_BENDERS *__pyx_v__benders; + SCIP_VAR *__pyx_v__mappedvar; + PyObject *__pyx_v_mappedvar = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_BENDERS *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBendersVar", 1); + + /* "src/pyscipopt/scip.pxi":3765 + * cdef SCIP_VAR* _mappedvar + * + * if benders is None: # <<<<<<<<<<<<<< + * _benders = SCIPfindBenders(self._scip, "default") + * else: + */ + __pyx_t_1 = (((PyObject *)__pyx_v_benders) == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3766 + * + * if benders is None: + * _benders = SCIPfindBenders(self._scip, "default") # <<<<<<<<<<<<<< + * else: + * _benders = benders._benders + */ + __pyx_v__benders = SCIPfindBenders(__pyx_v_self->_scip, ((char const *)"default")); + + /* "src/pyscipopt/scip.pxi":3765 + * cdef SCIP_VAR* _mappedvar + * + * if benders is None: # <<<<<<<<<<<<<< + * _benders = SCIPfindBenders(self._scip, "default") + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3768 + * _benders = SCIPfindBenders(self._scip, "default") + * else: + * _benders = benders._benders # <<<<<<<<<<<<<< + * + * if probnumber == -1: + */ + /*else*/ { + __pyx_t_2 = __pyx_v_benders->_benders; + __pyx_v__benders = __pyx_t_2; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3770 + * _benders = benders._benders + * + * if probnumber == -1: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPgetBendersMasterVar(self._scip, _benders, var.scip_var, &_mappedvar)) + * else: + */ + __pyx_t_1 = (__Pyx_PyInt_BoolEqObjC(__pyx_v_probnumber, __pyx_int_neg_1, -1L, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 3770, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3771 + * + * if probnumber == -1: + * PY_SCIP_CALL(SCIPgetBendersMasterVar(self._scip, _benders, var.scip_var, &_mappedvar)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPgetBendersSubproblemVar(self._scip, _benders, var.scip_var, &_mappedvar, probnumber)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetBendersMasterVar(__pyx_v_self->_scip, __pyx_v__benders, __pyx_v_var->scip_var, (&__pyx_v__mappedvar))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3770 + * _benders = benders._benders + * + * if probnumber == -1: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPgetBendersMasterVar(self._scip, _benders, var.scip_var, &_mappedvar)) + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3773 + * PY_SCIP_CALL(SCIPgetBendersMasterVar(self._scip, _benders, var.scip_var, &_mappedvar)) + * else: + * PY_SCIP_CALL(SCIPgetBendersSubproblemVar(self._scip, _benders, var.scip_var, &_mappedvar, probnumber)) # <<<<<<<<<<<<<< + * + * if _mappedvar == NULL: + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_probnumber); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3773, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetBendersSubproblemVar(__pyx_v_self->_scip, __pyx_v__benders, __pyx_v_var->scip_var, (&__pyx_v__mappedvar), __pyx_t_7)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3775 + * PY_SCIP_CALL(SCIPgetBendersSubproblemVar(self._scip, _benders, var.scip_var, &_mappedvar, probnumber)) + * + * if _mappedvar == NULL: # <<<<<<<<<<<<<< + * mappedvar = None + * else: + */ + __pyx_t_1 = (__pyx_v__mappedvar == NULL); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3776 + * + * if _mappedvar == NULL: + * mappedvar = None # <<<<<<<<<<<<<< + * else: + * mappedvar = Variable.create(_mappedvar) + */ + __Pyx_INCREF(Py_None); + __pyx_v_mappedvar = Py_None; + + /* "src/pyscipopt/scip.pxi":3775 + * PY_SCIP_CALL(SCIPgetBendersSubproblemVar(self._scip, _benders, var.scip_var, &_mappedvar, probnumber)) + * + * if _mappedvar == NULL: # <<<<<<<<<<<<<< + * mappedvar = None + * else: + */ + goto __pyx_L5; + } + + /* "src/pyscipopt/scip.pxi":3778 + * mappedvar = None + * else: + * mappedvar = Variable.create(_mappedvar) # <<<<<<<<<<<<<< + * + * return mappedvar + */ + /*else*/ { + __pyx_t_3 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v__mappedvar); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_mappedvar = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_L5:; + + /* "src/pyscipopt/scip.pxi":3780 + * mappedvar = Variable.create(_mappedvar) + * + * return mappedvar # <<<<<<<<<<<<<< + * + * def getBendersAuxiliaryVar(self, probnumber, Benders benders = None): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_mappedvar); + __pyx_r = __pyx_v_mappedvar; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3753 + * return Model.create(scip_subprob) + * + * def getBendersVar(self, Variable var, Benders benders = None, probnumber = -1): # <<<<<<<<<<<<<< + * """Returns the variable for the subproblem or master problem + * depending on the input probnumber + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBendersVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_mappedvar); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3782 + * return mappedvar + * + * def getBendersAuxiliaryVar(self, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns the auxiliary variable that is associated with the input problem number + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_411getBendersAuxiliaryVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_410getBendersAuxiliaryVar, "Model.getBendersAuxiliaryVar(self, probnumber, Benders benders=None)\nReturns the auxiliary variable that is associated with the input problem number\n\n Keyword arguments:\n probnumber -- the problem number for which the target variable belongs, -1 for master problem\n benders -- the Benders' decomposition to which the subproblem variables belong to\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_411getBendersAuxiliaryVar = {"getBendersAuxiliaryVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_411getBendersAuxiliaryVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_410getBendersAuxiliaryVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_411getBendersAuxiliaryVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_probnumber = 0; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBendersAuxiliaryVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_probnumber,&__pyx_n_s_benders,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3782, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3782, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getBendersAuxiliaryVar") < 0)) __PYX_ERR(0, 3782, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_probnumber = values[0]; + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getBendersAuxiliaryVar", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 3782, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getBendersAuxiliaryVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3782, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_410getBendersAuxiliaryVar(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_probnumber, __pyx_v_benders); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_410getBendersAuxiliaryVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probnumber, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders) { + SCIP_BENDERS *__pyx_v__benders; + SCIP_VAR *__pyx_v__auxvar; + PyObject *__pyx_v_auxvar = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_BENDERS *__pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBendersAuxiliaryVar", 1); + + /* "src/pyscipopt/scip.pxi":3792 + * cdef SCIP_VAR* _auxvar + * + * if benders is None: # <<<<<<<<<<<<<< + * _benders = SCIPfindBenders(self._scip, "default") + * else: + */ + __pyx_t_1 = (((PyObject *)__pyx_v_benders) == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3793 + * + * if benders is None: + * _benders = SCIPfindBenders(self._scip, "default") # <<<<<<<<<<<<<< + * else: + * _benders = benders._benders + */ + __pyx_v__benders = SCIPfindBenders(__pyx_v_self->_scip, ((char const *)"default")); + + /* "src/pyscipopt/scip.pxi":3792 + * cdef SCIP_VAR* _auxvar + * + * if benders is None: # <<<<<<<<<<<<<< + * _benders = SCIPfindBenders(self._scip, "default") + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3795 + * _benders = SCIPfindBenders(self._scip, "default") + * else: + * _benders = benders._benders # <<<<<<<<<<<<<< + * + * _auxvar = SCIPbendersGetAuxiliaryVar(_benders, probnumber) + */ + /*else*/ { + __pyx_t_2 = __pyx_v_benders->_benders; + __pyx_v__benders = __pyx_t_2; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3797 + * _benders = benders._benders + * + * _auxvar = SCIPbendersGetAuxiliaryVar(_benders, probnumber) # <<<<<<<<<<<<<< + * auxvar = Variable.create(_auxvar) + * + */ + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_probnumber); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3797, __pyx_L1_error) + __pyx_v__auxvar = SCIPbendersGetAuxiliaryVar(__pyx_v__benders, __pyx_t_3); + + /* "src/pyscipopt/scip.pxi":3798 + * + * _auxvar = SCIPbendersGetAuxiliaryVar(_benders, probnumber) + * auxvar = Variable.create(_auxvar) # <<<<<<<<<<<<<< + * + * return auxvar + */ + __pyx_t_4 = __pyx_f_9pyscipopt_4scip_8Variable_create(__pyx_v__auxvar); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3798, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_auxvar = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":3800 + * auxvar = Variable.create(_auxvar) + * + * return auxvar # <<<<<<<<<<<<<< + * + * def checkBendersSubproblemOptimality(self, Solution solution, probnumber, Benders benders = None): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_auxvar); + __pyx_r = __pyx_v_auxvar; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3782 + * return mappedvar + * + * def getBendersAuxiliaryVar(self, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns the auxiliary variable that is associated with the input problem number + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBendersAuxiliaryVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_auxvar); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3802 + * return auxvar + * + * def checkBendersSubproblemOptimality(self, Solution solution, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns whether the subproblem is optimal w.r.t the master problem auxiliary variables. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_413checkBendersSubproblemOptimality(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_412checkBendersSubproblemOptimality, "Model.checkBendersSubproblemOptimality(self, Solution solution, probnumber, Benders benders=None)\nReturns whether the subproblem is optimal w.r.t the master problem auxiliary variables.\n\n Keyword arguments:\n solution -- the master problem solution that is being checked for optimamlity\n probnumber -- the problem number for which optimality is being checked\n benders -- the Benders' decomposition to which the subproblem belongs to\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_413checkBendersSubproblemOptimality = {"checkBendersSubproblemOptimality", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_413checkBendersSubproblemOptimality, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_412checkBendersSubproblemOptimality}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_413checkBendersSubproblemOptimality(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_probnumber = 0; + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("checkBendersSubproblemOptimality (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_probnumber,&__pyx_n_s_benders,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3802, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probnumber)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3802, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("checkBendersSubproblemOptimality", 0, 2, 3, 1); __PYX_ERR(0, 3802, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3802, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "checkBendersSubproblemOptimality") < 0)) __PYX_ERR(0, 3802, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_probnumber = values[1]; + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("checkBendersSubproblemOptimality", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 3802, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.checkBendersSubproblemOptimality", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 3802, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3802, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_412checkBendersSubproblemOptimality(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution, __pyx_v_probnumber, __pyx_v_benders); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_412checkBendersSubproblemOptimality(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_probnumber, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders) { + SCIP_BENDERS *__pyx_v__benders; + SCIP_SOL *__pyx_v_scip_sol; + SCIP_Bool __pyx_v_optimal; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + SCIP_BENDERS *__pyx_t_2; + SCIP_SOL *__pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("checkBendersSubproblemOptimality", 1); + + /* "src/pyscipopt/scip.pxi":3814 + * cdef SCIP_Bool optimal + * + * if benders is None: # <<<<<<<<<<<<<< + * _benders = SCIPfindBenders(self._scip, "default") + * else: + */ + __pyx_t_1 = (((PyObject *)__pyx_v_benders) == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3815 + * + * if benders is None: + * _benders = SCIPfindBenders(self._scip, "default") # <<<<<<<<<<<<<< + * else: + * _benders = benders._benders + */ + __pyx_v__benders = SCIPfindBenders(__pyx_v_self->_scip, ((char const *)"default")); + + /* "src/pyscipopt/scip.pxi":3814 + * cdef SCIP_Bool optimal + * + * if benders is None: # <<<<<<<<<<<<<< + * _benders = SCIPfindBenders(self._scip, "default") + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":3817 + * _benders = SCIPfindBenders(self._scip, "default") + * else: + * _benders = benders._benders # <<<<<<<<<<<<<< + * + * if isinstance(solution, Solution): + */ + /*else*/ { + __pyx_t_2 = __pyx_v_benders->_benders; + __pyx_v__benders = __pyx_t_2; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":3819 + * _benders = benders._benders + * + * if isinstance(solution, Solution): # <<<<<<<<<<<<<< + * scip_sol = solution.sol + * else: + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":3820 + * + * if isinstance(solution, Solution): + * scip_sol = solution.sol # <<<<<<<<<<<<<< + * else: + * scip_sol = NULL + */ + __pyx_t_3 = __pyx_v_solution->sol; + __pyx_v_scip_sol = __pyx_t_3; + + /* "src/pyscipopt/scip.pxi":3819 + * _benders = benders._benders + * + * if isinstance(solution, Solution): # <<<<<<<<<<<<<< + * scip_sol = solution.sol + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":3822 + * scip_sol = solution.sol + * else: + * scip_sol = NULL # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL( SCIPcheckBendersSubproblemOptimality(self._scip, _benders, + */ + /*else*/ { + __pyx_v_scip_sol = NULL; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":3824 + * scip_sol = NULL + * + * PY_SCIP_CALL( SCIPcheckBendersSubproblemOptimality(self._scip, _benders, # <<<<<<<<<<<<<< + * scip_sol, probnumber, &optimal) ) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3824, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "src/pyscipopt/scip.pxi":3825 + * + * PY_SCIP_CALL( SCIPcheckBendersSubproblemOptimality(self._scip, _benders, + * scip_sol, probnumber, &optimal) ) # <<<<<<<<<<<<<< + * + * return optimal + */ + __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_probnumber); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3825, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3824 + * scip_sol = NULL + * + * PY_SCIP_CALL( SCIPcheckBendersSubproblemOptimality(self._scip, _benders, # <<<<<<<<<<<<<< + * scip_sol, probnumber, &optimal) ) + * + */ + __pyx_t_7 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcheckBendersSubproblemOptimality(__pyx_v_self->_scip, __pyx_v__benders, __pyx_v_scip_sol, __pyx_t_6, (&__pyx_v_optimal))); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3824, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_7}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3824, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":3827 + * scip_sol, probnumber, &optimal) ) + * + * return optimal # <<<<<<<<<<<<<< + * + * def includeBendersDefaultCuts(self, Benders benders): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_optimal); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3827, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3802 + * return auxvar + * + * def checkBendersSubproblemOptimality(self, Solution solution, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns whether the subproblem is optimal w.r.t the master problem auxiliary variables. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.checkBendersSubproblemOptimality", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3829 + * return optimal + * + * def includeBendersDefaultCuts(self, Benders benders): # <<<<<<<<<<<<<< + * """includes the default Benders' decomposition cuts to the custom Benders' decomposition plugin + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_415includeBendersDefaultCuts(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_414includeBendersDefaultCuts, "Model.includeBendersDefaultCuts(self, Benders benders)\nincludes the default Benders' decomposition cuts to the custom Benders' decomposition plugin\n\n Keyword arguments:\n benders -- the Benders' decomposition that the default cuts will be applied to\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_415includeBendersDefaultCuts = {"includeBendersDefaultCuts", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_415includeBendersDefaultCuts, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_414includeBendersDefaultCuts}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_415includeBendersDefaultCuts(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeBendersDefaultCuts (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_benders,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3829, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeBendersDefaultCuts") < 0)) __PYX_ERR(0, 3829, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeBendersDefaultCuts", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 3829, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeBendersDefaultCuts", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 3829, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_414includeBendersDefaultCuts(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_benders); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_414includeBendersDefaultCuts(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeBendersDefaultCuts", 1); + + /* "src/pyscipopt/scip.pxi":3835 + * benders -- the Benders' decomposition that the default cuts will be applied to + * """ + * PY_SCIP_CALL( SCIPincludeBendersDefaultCuts(self._scip, benders._benders) ) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeBendersDefaultCuts(__pyx_v_self->_scip, __pyx_v_benders->_benders)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3829 + * return optimal + * + * def includeBendersDefaultCuts(self, Benders benders): # <<<<<<<<<<<<<< + * """includes the default Benders' decomposition cuts to the custom Benders' decomposition plugin + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeBendersDefaultCuts", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3838 + * + * + * def includeEventhdlr(self, Eventhdlr eventhdlr, name, desc): # <<<<<<<<<<<<<< + * """Include an event handler. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_417includeEventhdlr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_416includeEventhdlr, "Model.includeEventhdlr(self, Eventhdlr eventhdlr, name, desc)\nInclude an event handler.\n\n Keyword arguments:\n eventhdlr -- event handler\n name -- name of event handler\n desc -- description of event handler\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_417includeEventhdlr = {"includeEventhdlr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_417includeEventhdlr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_416includeEventhdlr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_417includeEventhdlr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeEventhdlr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eventhdlr,&__pyx_n_s_name,&__pyx_n_s_desc,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventhdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3838, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3838, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeEventhdlr", 1, 3, 3, 1); __PYX_ERR(0, 3838, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3838, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeEventhdlr", 1, 3, 3, 2); __PYX_ERR(0, 3838, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeEventhdlr") < 0)) __PYX_ERR(0, 3838, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_eventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeEventhdlr", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 3838, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeEventhdlr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr, 1, "eventhdlr", 0))) __PYX_ERR(0, 3838, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_416includeEventhdlr(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_eventhdlr, __pyx_v_name, __pyx_v_desc); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_416includeEventhdlr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr, PyObject *__pyx_v_name, PyObject *__pyx_v_desc) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeEventhdlr", 1); + + /* "src/pyscipopt/scip.pxi":3846 + * desc -- description of event handler + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeEventhdlr(self._scip, n, d, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3846, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3846, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3847 + * """ + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeEventhdlr(self._scip, n, d, + * PyEventCopy, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3847, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3847, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_d = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3848 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeEventhdlr(self._scip, n, d, # <<<<<<<<<<<<<< + * PyEventCopy, + * PyEventFree, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3848, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 3848, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 3848, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3857 + * PyEventDelete, + * PyEventExec, + * eventhdlr)) # <<<<<<<<<<<<<< + * eventhdlr.model = weakref.proxy(self) + * eventhdlr.name = name + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeEventhdlr(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_f_9pyscipopt_4scip_PyEventCopy, __pyx_f_9pyscipopt_4scip_PyEventFree, __pyx_f_9pyscipopt_4scip_PyEventInit, __pyx_f_9pyscipopt_4scip_PyEventExit, __pyx_f_9pyscipopt_4scip_PyEventInitsol, __pyx_f_9pyscipopt_4scip_PyEventExitsol, __pyx_f_9pyscipopt_4scip_PyEventDelete, __pyx_f_9pyscipopt_4scip_PyEventExec, ((SCIP_EVENTHDLRDATA *)__pyx_v_eventhdlr))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3848, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3848, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3858 + * PyEventExec, + * eventhdlr)) + * eventhdlr.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * eventhdlr.name = name + * Py_INCREF(eventhdlr) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3858, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3858, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3858, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_eventhdlr->model); + __Pyx_DECREF((PyObject *)__pyx_v_eventhdlr->model); + __pyx_v_eventhdlr->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3859 + * eventhdlr)) + * eventhdlr.model = weakref.proxy(self) + * eventhdlr.name = name # <<<<<<<<<<<<<< + * Py_INCREF(eventhdlr) + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(0, 3859, __pyx_L1_error) + __pyx_t_3 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_eventhdlr->name); + __Pyx_DECREF(__pyx_v_eventhdlr->name); + __pyx_v_eventhdlr->name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3860 + * eventhdlr.model = weakref.proxy(self) + * eventhdlr.name = name + * Py_INCREF(eventhdlr) # <<<<<<<<<<<<<< + * + * def includePricer(self, Pricer pricer, name, desc, priority=1, delay=True): + */ + Py_INCREF(((PyObject *)__pyx_v_eventhdlr)); + + /* "src/pyscipopt/scip.pxi":3838 + * + * + * def includeEventhdlr(self, Eventhdlr eventhdlr, name, desc): # <<<<<<<<<<<<<< + * """Include an event handler. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeEventhdlr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3862 + * Py_INCREF(eventhdlr) + * + * def includePricer(self, Pricer pricer, name, desc, priority=1, delay=True): # <<<<<<<<<<<<<< + * """Include a pricer. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_419includePricer(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_418includePricer, "Model.includePricer(self, Pricer pricer, name, desc, priority=1, delay=True)\nInclude a pricer.\n\n :param Pricer pricer: pricer\n :param name: name of pricer\n :param desc: description of pricer\n :param priority: priority of pricer (Default value = 1)\n :param delay: should the pricer be delayed until no other pricers or already existing problem variables with negative reduced costs are found? (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_419includePricer = {"includePricer", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_419includePricer, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_418includePricer}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_419includePricer(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_pricer = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_delay = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includePricer (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pricer,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_priority,&__pyx_n_s_delay,0}; + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_1)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pricer)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3862, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3862, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includePricer", 0, 3, 5, 1); __PYX_ERR(0, 3862, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3862, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includePricer", 0, 3, 5, 2); __PYX_ERR(0, 3862, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3862, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_delay); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3862, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includePricer") < 0)) __PYX_ERR(0, 3862, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_pricer = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_priority = values[3]; + __pyx_v_delay = values[4]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includePricer", 0, 3, 5, __pyx_nargs); __PYX_ERR(0, 3862, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includePricer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pricer), __pyx_ptype_9pyscipopt_4scip_Pricer, 1, "pricer", 0))) __PYX_ERR(0, 3862, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_418includePricer(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_pricer, __pyx_v_name, __pyx_v_desc, __pyx_v_priority, __pyx_v_delay); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_418includePricer(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v_pricer, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_delay) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + SCIP_PRICER *__pyx_v_scip_pricer; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + SCIP_Bool __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + char const *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includePricer", 1); + + /* "src/pyscipopt/scip.pxi":3872 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludePricer(self._scip, n, d, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3872, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3872, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3873 + * """ + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludePricer(self._scip, n, d, + * priority, delay, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3873, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3873, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_d = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3874 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludePricer(self._scip, n, d, # <<<<<<<<<<<<<< + * priority, delay, + * PyPricerCopy, PyPricerFree, PyPricerInit, PyPricerExit, PyPricerInitsol, PyPricerExitsol, PyPricerRedcost, PyPricerFarkas, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 3874, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 3874, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3875 + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludePricer(self._scip, n, d, + * priority, delay, # <<<<<<<<<<<<<< + * PyPricerCopy, PyPricerFree, PyPricerInit, PyPricerExit, PyPricerInitsol, PyPricerExitsol, PyPricerRedcost, PyPricerFarkas, + * pricer)) + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3875, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_delay); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3875, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3874 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludePricer(self._scip, n, d, # <<<<<<<<<<<<<< + * priority, delay, + * PyPricerCopy, PyPricerFree, PyPricerInit, PyPricerExit, PyPricerInitsol, PyPricerExitsol, PyPricerRedcost, PyPricerFarkas, + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludePricer(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_f_9pyscipopt_4scip_PyPricerCopy, __pyx_f_9pyscipopt_4scip_PyPricerFree, __pyx_f_9pyscipopt_4scip_PyPricerInit, __pyx_f_9pyscipopt_4scip_PyPricerExit, __pyx_f_9pyscipopt_4scip_PyPricerInitsol, __pyx_f_9pyscipopt_4scip_PyPricerExitsol, __pyx_f_9pyscipopt_4scip_PyPricerRedcost, __pyx_f_9pyscipopt_4scip_PyPricerFarkas, ((SCIP_PRICERDATA *)__pyx_v_pricer))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3879 + * pricer)) + * cdef SCIP_PRICER* scip_pricer + * scip_pricer = SCIPfindPricer(self._scip, n) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPactivatePricer(self._scip, scip_pricer)) + * pricer.model = weakref.proxy(self) + */ + __pyx_t_9 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(0, 3879, __pyx_L1_error) + __pyx_v_scip_pricer = SCIPfindPricer(__pyx_v_self->_scip, __pyx_t_9); + + /* "src/pyscipopt/scip.pxi":3880 + * cdef SCIP_PRICER* scip_pricer + * scip_pricer = SCIPfindPricer(self._scip, n) + * PY_SCIP_CALL(SCIPactivatePricer(self._scip, scip_pricer)) # <<<<<<<<<<<<<< + * pricer.model = weakref.proxy(self) + * Py_INCREF(pricer) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPactivatePricer(__pyx_v_self->_scip, __pyx_v_scip_pricer)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3881 + * scip_pricer = SCIPfindPricer(self._scip, n) + * PY_SCIP_CALL(SCIPactivatePricer(self._scip, scip_pricer)) + * pricer.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * Py_INCREF(pricer) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3881, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3881, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3881, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_pricer->model); + __Pyx_DECREF((PyObject *)__pyx_v_pricer->model); + __pyx_v_pricer->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3882 + * PY_SCIP_CALL(SCIPactivatePricer(self._scip, scip_pricer)) + * pricer.model = weakref.proxy(self) + * Py_INCREF(pricer) # <<<<<<<<<<<<<< + * + * def includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0, + */ + Py_INCREF(((PyObject *)__pyx_v_pricer)); + + /* "src/pyscipopt/scip.pxi":3862 + * Py_INCREF(eventhdlr) + * + * def includePricer(self, Pricer pricer, name, desc, priority=1, delay=True): # <<<<<<<<<<<<<< + * """Include a pricer. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.includePricer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3884 + * Py_INCREF(pricer) + * + * def includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0, # <<<<<<<<<<<<<< + * enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1, + * eagerfreq=100, maxprerounds=-1, delaysepa=False, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_421includeConshdlr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_420includeConshdlr, "Model.includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0, enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1, eagerfreq=100, maxprerounds=-1, delaysepa=False, delayprop=False, needscons=True, proptiming=PY_SCIP_PROPTIMING.BEFORELP, presoltiming=PY_SCIP_PRESOLTIMING.MEDIUM)\nInclude a constraint handler\n\n :param Conshdlr conshdlr: constraint handler\n :param name: name of constraint handler\n :param desc: description of constraint handler\n :param sepapriority: priority for separation (Default value = 0)\n :param enfopriority: priority for constraint enforcing (Default value = 0)\n :param chckpriority: priority for checking feasibility (Default value = 0)\n :param sepafreq: frequency for separating cuts; 0 = only at root node (Default value = -1)\n :param propfreq: frequency for propagating domains; 0 = only preprocessing propagation (Default value = -1)\n :param eagerfreq: frequency for using all instead of only the useful constraints in separation, propagation and enforcement; -1 = no eager evaluations, 0 = first only (Default value = 100)\n :param maxprerounds: maximal number of presolving rounds the constraint handler participates in (Default value = -1)\n :param delaysepa: should separation method be delayed, if other separators found cuts? (Default value = False)\n :param delayprop: should propagation method be delayed, if other propagators found reductions? (Default value = False)\n :param needscons: should the constraint handler be skipped, if no constraints are available? (Default value = True)\n :param proptiming: positions in the node solving loop where propagation method of constraint handlers should be executed (Default value = SCIP_PROPTIMING.BEFORELP)\n :param presoltiming: timing mask of the constraint handler's presolving method (Default value = SCIP_PRESOLTIMING.MEDIUM)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_421includeConshdlr = {"includeConshdlr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_421includeConshdlr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_420includeConshdlr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_421includeConshdlr(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_conshdlr = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_sepapriority = 0; + PyObject *__pyx_v_enfopriority = 0; + PyObject *__pyx_v_chckpriority = 0; + PyObject *__pyx_v_sepafreq = 0; + PyObject *__pyx_v_propfreq = 0; + PyObject *__pyx_v_eagerfreq = 0; + PyObject *__pyx_v_maxprerounds = 0; + PyObject *__pyx_v_delaysepa = 0; + PyObject *__pyx_v_delayprop = 0; + PyObject *__pyx_v_needscons = 0; + PyObject *__pyx_v_proptiming = 0; + PyObject *__pyx_v_presoltiming = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeConshdlr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conshdlr,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_sepapriority,&__pyx_n_s_enfopriority,&__pyx_n_s_chckpriority,&__pyx_n_s_sepafreq,&__pyx_n_s_propfreq,&__pyx_n_s_eagerfreq,&__pyx_n_s_maxprerounds,&__pyx_n_s_delaysepa,&__pyx_n_s_delayprop,&__pyx_n_s_needscons,&__pyx_n_s_proptiming,&__pyx_n_s_presoltiming,0}; + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_0)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_0)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_0)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_neg_1)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_neg_1)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_100)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_neg_1)); + + /* "src/pyscipopt/scip.pxi":3886 + * def includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0, + * enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1, + * eagerfreq=100, maxprerounds=-1, delaysepa=False, # <<<<<<<<<<<<<< + * delayprop=False, needscons=True, + * proptiming=PY_SCIP_PROPTIMING.BEFORELP, + */ + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + + /* "src/pyscipopt/scip.pxi":3887 + * enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1, + * eagerfreq=100, maxprerounds=-1, delaysepa=False, + * delayprop=False, needscons=True, # <<<<<<<<<<<<<< + * proptiming=PY_SCIP_PROPTIMING.BEFORELP, + * presoltiming=PY_SCIP_PRESOLTIMING.MEDIUM): + */ + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[12] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[13] = __Pyx_Arg_NewRef_FASTCALL(__pyx_k__102); + values[14] = __Pyx_Arg_NewRef_FASTCALL(__pyx_k__103); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 15: values[14] = __Pyx_Arg_FASTCALL(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_conshdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeConshdlr", 0, 3, 15, 1); __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeConshdlr", 0, 3, 15, 2); __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sepapriority); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enfopriority); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_chckpriority); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sepafreq); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propfreq); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eagerfreq); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxprerounds); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_delaysepa); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_delayprop); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 12: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_needscons); + if (value) { values[12] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 13: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_proptiming); + if (value) { values[13] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 14: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_presoltiming); + if (value) { values[14] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3884, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeConshdlr") < 0)) __PYX_ERR(0, 3884, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 15: values[14] = __Pyx_Arg_FASTCALL(__pyx_args, 14); + CYTHON_FALLTHROUGH; + case 14: values[13] = __Pyx_Arg_FASTCALL(__pyx_args, 13); + CYTHON_FALLTHROUGH; + case 13: values[12] = __Pyx_Arg_FASTCALL(__pyx_args, 12); + CYTHON_FALLTHROUGH; + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_conshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_sepapriority = values[3]; + __pyx_v_enfopriority = values[4]; + __pyx_v_chckpriority = values[5]; + __pyx_v_sepafreq = values[6]; + __pyx_v_propfreq = values[7]; + __pyx_v_eagerfreq = values[8]; + __pyx_v_maxprerounds = values[9]; + __pyx_v_delaysepa = values[10]; + __pyx_v_delayprop = values[11]; + __pyx_v_needscons = values[12]; + __pyx_v_proptiming = values[13]; + __pyx_v_presoltiming = values[14]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeConshdlr", 0, 3, 15, __pyx_nargs); __PYX_ERR(0, 3884, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeConshdlr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_conshdlr), __pyx_ptype_9pyscipopt_4scip_Conshdlr, 1, "conshdlr", 0))) __PYX_ERR(0, 3884, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_420includeConshdlr(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_conshdlr, __pyx_v_name, __pyx_v_desc, __pyx_v_sepapriority, __pyx_v_enfopriority, __pyx_v_chckpriority, __pyx_v_sepafreq, __pyx_v_propfreq, __pyx_v_eagerfreq, __pyx_v_maxprerounds, __pyx_v_delaysepa, __pyx_v_delayprop, __pyx_v_needscons, __pyx_v_proptiming, __pyx_v_presoltiming); + + /* "src/pyscipopt/scip.pxi":3884 + * Py_INCREF(pricer) + * + * def includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0, # <<<<<<<<<<<<<< + * enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1, + * eagerfreq=100, maxprerounds=-1, delaysepa=False, + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_420includeConshdlr(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_conshdlr, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_sepapriority, PyObject *__pyx_v_enfopriority, PyObject *__pyx_v_chckpriority, PyObject *__pyx_v_sepafreq, PyObject *__pyx_v_propfreq, PyObject *__pyx_v_eagerfreq, PyObject *__pyx_v_maxprerounds, PyObject *__pyx_v_delaysepa, PyObject *__pyx_v_delayprop, PyObject *__pyx_v_needscons, PyObject *__pyx_v_proptiming, PyObject *__pyx_v_presoltiming) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_PROPTIMING __pyx_t_16; + SCIP_PRESOLTIMING __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeConshdlr", 1); + + /* "src/pyscipopt/scip.pxi":3909 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeConshdlr(self._scip, n, d, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3909, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3909, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3910 + * """ + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeConshdlr(self._scip, n, d, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, + * maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3910, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3910, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_d = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3911 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeConshdlr(self._scip, n, d, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, # <<<<<<<<<<<<<< + * maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, + * PyConshdlrCopy, PyConsFree, PyConsInit, PyConsExit, PyConsInitpre, PyConsExitpre, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 3911, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 3911, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_sepapriority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3911, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_enfopriority); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3911, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_chckpriority); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3911, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_sepafreq); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3911, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_propfreq); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3911, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_v_eagerfreq); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3911, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3912 + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeConshdlr(self._scip, n, d, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, + * maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, # <<<<<<<<<<<<<< + * PyConshdlrCopy, PyConsFree, PyConsInit, PyConsExit, PyConsInitpre, PyConsExitpre, + * PyConsInitsol, PyConsExitsol, PyConsDelete, PyConsTrans, PyConsInitlp, PyConsSepalp, PyConsSepasol, + */ + __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_v_maxprerounds); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3912, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_delaysepa); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3912, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_delayprop); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3912, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_needscons); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3912, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyInt_As_SCIP_PROPTIMING(__pyx_v_proptiming); if (unlikely((__pyx_t_16 == ((SCIP_PROPTIMING)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3912, __pyx_L1_error) + __pyx_t_17 = __Pyx_PyInt_As_SCIP_PRESOLTIMING(__pyx_v_presoltiming); if (unlikely((__pyx_t_17 == ((SCIP_PRESOLTIMING)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3912, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3911 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeConshdlr(self._scip, n, d, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq, # <<<<<<<<<<<<<< + * maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming, + * PyConshdlrCopy, PyConsFree, PyConsInit, PyConsExit, PyConsInitpre, PyConsExitpre, + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeConshdlr(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_f_9pyscipopt_4scip_PyConshdlrCopy, __pyx_f_9pyscipopt_4scip_PyConsFree, __pyx_f_9pyscipopt_4scip_PyConsInit, __pyx_f_9pyscipopt_4scip_PyConsExit, __pyx_f_9pyscipopt_4scip_PyConsInitpre, __pyx_f_9pyscipopt_4scip_PyConsExitpre, __pyx_f_9pyscipopt_4scip_PyConsInitsol, __pyx_f_9pyscipopt_4scip_PyConsExitsol, __pyx_f_9pyscipopt_4scip_PyConsDelete, __pyx_f_9pyscipopt_4scip_PyConsTrans, __pyx_f_9pyscipopt_4scip_PyConsInitlp, __pyx_f_9pyscipopt_4scip_PyConsSepalp, __pyx_f_9pyscipopt_4scip_PyConsSepasol, __pyx_f_9pyscipopt_4scip_PyConsEnfolp, __pyx_f_9pyscipopt_4scip_PyConsEnforelax, __pyx_f_9pyscipopt_4scip_PyConsEnfops, __pyx_f_9pyscipopt_4scip_PyConsCheck, __pyx_f_9pyscipopt_4scip_PyConsProp, __pyx_f_9pyscipopt_4scip_PyConsPresol, __pyx_f_9pyscipopt_4scip_PyConsResprop, __pyx_f_9pyscipopt_4scip_PyConsLock, __pyx_f_9pyscipopt_4scip_PyConsActive, __pyx_f_9pyscipopt_4scip_PyConsDeactive, __pyx_f_9pyscipopt_4scip_PyConsEnable, __pyx_f_9pyscipopt_4scip_PyConsDisable, __pyx_f_9pyscipopt_4scip_PyConsDelvars, __pyx_f_9pyscipopt_4scip_PyConsPrint, __pyx_f_9pyscipopt_4scip_PyConsCopy, __pyx_f_9pyscipopt_4scip_PyConsParse, __pyx_f_9pyscipopt_4scip_PyConsGetvars, __pyx_f_9pyscipopt_4scip_PyConsGetnvars, __pyx_f_9pyscipopt_4scip_PyConsGetdivebdchgs, __pyx_f_9pyscipopt_4scip_PyConsGetPermSymGraph, __pyx_f_9pyscipopt_4scip_PyConsGetSignedPermSymGraph, ((SCIP_CONSHDLRDATA *)__pyx_v_conshdlr))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_18 = NULL; + __pyx_t_12 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_18)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_18); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_12 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_12, 1+__pyx_t_12); + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3919 + * PyConsParse, PyConsGetvars, PyConsGetnvars, PyConsGetdivebdchgs, PyConsGetPermSymGraph, PyConsGetSignedPermSymGraph, + * conshdlr)) + * conshdlr.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * conshdlr.name = name + * Py_INCREF(conshdlr) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_12 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_12 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_12, 1+__pyx_t_12); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_conshdlr->model); + __Pyx_DECREF((PyObject *)__pyx_v_conshdlr->model); + __pyx_v_conshdlr->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3920 + * conshdlr)) + * conshdlr.model = weakref.proxy(self) + * conshdlr.name = name # <<<<<<<<<<<<<< + * Py_INCREF(conshdlr) + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(0, 3920, __pyx_L1_error) + __pyx_t_3 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_conshdlr->name); + __Pyx_DECREF(__pyx_v_conshdlr->name); + __pyx_v_conshdlr->name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3921 + * conshdlr.model = weakref.proxy(self) + * conshdlr.name = name + * Py_INCREF(conshdlr) # <<<<<<<<<<<<<< + * + * def createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True, + */ + Py_INCREF(((PyObject *)__pyx_v_conshdlr)); + + /* "src/pyscipopt/scip.pxi":3884 + * Py_INCREF(pricer) + * + * def includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0, # <<<<<<<<<<<<<< + * enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1, + * eagerfreq=100, maxprerounds=-1, delaysepa=False, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeConshdlr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3923 + * Py_INCREF(conshdlr) + * + * def createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True, # <<<<<<<<<<<<<< + * local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False): + * """Create a constraint of a custom constraint handler + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_423createCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_422createCons, "Model.createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True, local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False)\nCreate a constraint of a custom constraint handler\n\n :param Conshdlr conshdlr: constraint handler\n :param name: name of constraint\n :param initial: (Default value = True)\n :param separate: (Default value = True)\n :param enforce: (Default value = True)\n :param check: (Default value = True)\n :param propagate: (Default value = True)\n :param local: (Default value = False)\n :param modifiable: (Default value = False)\n :param dynamic: (Default value = False)\n :param removable: (Default value = False)\n :param stickingatnode: (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_423createCons = {"createCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_423createCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_422createCons}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_423createCons(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_conshdlr = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_initial = 0; + PyObject *__pyx_v_separate = 0; + PyObject *__pyx_v_enforce = 0; + PyObject *__pyx_v_check = 0; + PyObject *__pyx_v_propagate = 0; + PyObject *__pyx_v_local = 0; + PyObject *__pyx_v_modifiable = 0; + PyObject *__pyx_v_dynamic = 0; + PyObject *__pyx_v_removable = 0; + PyObject *__pyx_v_stickingatnode = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createCons (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_conshdlr,&__pyx_n_s_name,&__pyx_n_s_initial,&__pyx_n_s_separate,&__pyx_n_s_enforce,&__pyx_n_s_check,&__pyx_n_s_propagate,&__pyx_n_s_local,&__pyx_n_s_modifiable,&__pyx_n_s_dynamic,&__pyx_n_s_removable,&__pyx_n_s_stickingatnode,0}; + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":3924 + * + * def createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True, + * local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False): # <<<<<<<<<<<<<< + * """Create a constraint of a custom constraint handler + * + */ + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[10] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[11] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_conshdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("createCons", 0, 2, 12, 1); __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_initial); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_separate); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_enforce); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_check); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_propagate); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_local); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_modifiable); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dynamic); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 10: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_removable); + if (value) { values[10] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 11: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stickingatnode); + if (value) { values[11] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3923, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createCons") < 0)) __PYX_ERR(0, 3923, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 12: values[11] = __Pyx_Arg_FASTCALL(__pyx_args, 11); + CYTHON_FALLTHROUGH; + case 11: values[10] = __Pyx_Arg_FASTCALL(__pyx_args, 10); + CYTHON_FALLTHROUGH; + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_conshdlr = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_initial = values[2]; + __pyx_v_separate = values[3]; + __pyx_v_enforce = values[4]; + __pyx_v_check = values[5]; + __pyx_v_propagate = values[6]; + __pyx_v_local = values[7]; + __pyx_v_modifiable = values[8]; + __pyx_v_dynamic = values[9]; + __pyx_v_removable = values[10]; + __pyx_v_stickingatnode = values[11]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createCons", 0, 2, 12, __pyx_nargs); __PYX_ERR(0, 3923, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_conshdlr), __pyx_ptype_9pyscipopt_4scip_Conshdlr, 1, "conshdlr", 0))) __PYX_ERR(0, 3923, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_422createCons(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_conshdlr, __pyx_v_name, __pyx_v_initial, __pyx_v_separate, __pyx_v_enforce, __pyx_v_check, __pyx_v_propagate, __pyx_v_local, __pyx_v_modifiable, __pyx_v_dynamic, __pyx_v_removable, __pyx_v_stickingatnode); + + /* "src/pyscipopt/scip.pxi":3923 + * Py_INCREF(conshdlr) + * + * def createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True, # <<<<<<<<<<<<<< + * local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False): + * """Create a constraint of a custom constraint handler + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_422createCons(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v_conshdlr, PyObject *__pyx_v_name, PyObject *__pyx_v_initial, PyObject *__pyx_v_separate, PyObject *__pyx_v_enforce, PyObject *__pyx_v_check, PyObject *__pyx_v_propagate, PyObject *__pyx_v_local, PyObject *__pyx_v_modifiable, PyObject *__pyx_v_dynamic, PyObject *__pyx_v_removable, PyObject *__pyx_v_stickingatnode) { + PyObject *__pyx_v_n = NULL; + SCIP_CONSHDLR *__pyx_v_scip_conshdlr; + struct __pyx_obj_9pyscipopt_4scip_Constraint *__pyx_v_constraint = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + SCIP_Bool __pyx_t_7; + SCIP_Bool __pyx_t_8; + SCIP_Bool __pyx_t_9; + SCIP_Bool __pyx_t_10; + SCIP_Bool __pyx_t_11; + SCIP_Bool __pyx_t_12; + SCIP_Bool __pyx_t_13; + SCIP_Bool __pyx_t_14; + SCIP_Bool __pyx_t_15; + SCIP_Bool __pyx_t_16; + PyObject *__pyx_t_17 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createCons", 1); + + /* "src/pyscipopt/scip.pxi":3942 + * """ + * + * n = str_conversion(name) # <<<<<<<<<<<<<< + * cdef SCIP_CONSHDLR* scip_conshdlr + * scip_conshdlr = SCIPfindConshdlr(self._scip, str_conversion(conshdlr.name)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3944 + * n = str_conversion(name) + * cdef SCIP_CONSHDLR* scip_conshdlr + * scip_conshdlr = SCIPfindConshdlr(self._scip, str_conversion(conshdlr.name)) # <<<<<<<<<<<<<< + * constraint = Constraint() + * PY_SCIP_CALL(SCIPcreateCons(self._scip, &(constraint.scip_cons), n, scip_conshdlr, constraint, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_conshdlr->name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_t_1); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 3944, __pyx_L1_error) + __pyx_v_scip_conshdlr = SCIPfindConshdlr(__pyx_v_self->_scip, __pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3945 + * cdef SCIP_CONSHDLR* scip_conshdlr + * scip_conshdlr = SCIPfindConshdlr(self._scip, str_conversion(conshdlr.name)) + * constraint = Constraint() # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateCons(self._scip, &(constraint.scip_cons), n, scip_conshdlr, constraint, + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + */ + __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_constraint = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3946 + * scip_conshdlr = SCIPfindConshdlr(self._scip, str_conversion(conshdlr.name)) + * constraint = Constraint() + * PY_SCIP_CALL(SCIPcreateCons(self._scip, &(constraint.scip_cons), n, scip_conshdlr, constraint, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * return constraint + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3946, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 3946, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3947 + * constraint = Constraint() + * PY_SCIP_CALL(SCIPcreateCons(self._scip, &(constraint.scip_cons), n, scip_conshdlr, constraint, + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) # <<<<<<<<<<<<<< + * return constraint + * + */ + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_initial); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_separate); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_enforce); if (unlikely((__pyx_t_9 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_propagate); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_local); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_v_modifiable); if (unlikely((__pyx_t_13 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_dynamic); if (unlikely((__pyx_t_14 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_v_removable); if (unlikely((__pyx_t_15 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_v_stickingatnode); if (unlikely((__pyx_t_16 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3947, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3946 + * scip_conshdlr = SCIPfindConshdlr(self._scip, str_conversion(conshdlr.name)) + * constraint = Constraint() + * PY_SCIP_CALL(SCIPcreateCons(self._scip, &(constraint.scip_cons), n, scip_conshdlr, constraint, # <<<<<<<<<<<<<< + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * return constraint + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateCons(__pyx_v_self->_scip, (&__pyx_v_constraint->scip_cons), __pyx_t_6, __pyx_v_scip_conshdlr, ((SCIP_CONSDATA *)__pyx_v_constraint), __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3946, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_17 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_17 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_17)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_17); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_17, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3946, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3948 + * PY_SCIP_CALL(SCIPcreateCons(self._scip, &(constraint.scip_cons), n, scip_conshdlr, constraint, + * initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode)) + * return constraint # <<<<<<<<<<<<<< + * + * def includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=SCIP_PRESOLTIMING_FAST): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_constraint); + __pyx_r = ((PyObject *)__pyx_v_constraint); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":3923 + * Py_INCREF(conshdlr) + * + * def createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True, # <<<<<<<<<<<<<< + * local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False): + * """Create a constraint of a custom constraint handler + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_AddTraceback("pyscipopt.scip.Model.createCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF((PyObject *)__pyx_v_constraint); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3950 + * return constraint + * + * def includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=SCIP_PRESOLTIMING_FAST): # <<<<<<<<<<<<<< + * """Include a presolver + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_425includePresol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_424includePresol, "Model.includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=SCIP_PRESOLTIMING_FAST)\nInclude a presolver\n\n :param Presol presol: presolver\n :param name: name of presolver\n :param desc: description of presolver\n :param priority: priority of the presolver (>= 0: before, < 0: after constraint handlers)\n :param maxrounds: maximal number of presolving rounds the presolver participates in (-1: no limit)\n :param timing: timing mask of presolver (Default value = SCIP_PRESOLTIMING_FAST)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_425includePresol = {"includePresol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_425includePresol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_424includePresol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_425includePresol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_presol = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_maxrounds = 0; + PyObject *__pyx_v_timing = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[6] = {0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includePresol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_presol,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_priority,&__pyx_n_s_maxrounds,&__pyx_n_s_timing,0}; + values[5] = __Pyx_Arg_NewRef_FASTCALL(__pyx_k__104); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_presol)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3950, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3950, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includePresol", 0, 5, 6, 1); __PYX_ERR(0, 3950, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3950, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includePresol", 0, 5, 6, 2); __PYX_ERR(0, 3950, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3950, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includePresol", 0, 5, 6, 3); __PYX_ERR(0, 3950, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxrounds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3950, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includePresol", 0, 5, 6, 4); __PYX_ERR(0, 3950, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timing); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3950, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includePresol") < 0)) __PYX_ERR(0, 3950, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_presol = ((struct __pyx_obj_9pyscipopt_4scip_Presol *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_priority = values[3]; + __pyx_v_maxrounds = values[4]; + __pyx_v_timing = values[5]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includePresol", 0, 5, 6, __pyx_nargs); __PYX_ERR(0, 3950, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includePresol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_presol), __pyx_ptype_9pyscipopt_4scip_Presol, 1, "presol", 0))) __PYX_ERR(0, 3950, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_424includePresol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_presol, __pyx_v_name, __pyx_v_desc, __pyx_v_priority, __pyx_v_maxrounds, __pyx_v_timing); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_424includePresol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v_presol, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_maxrounds, PyObject *__pyx_v_timing) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + int __pyx_t_7; + SCIP_PRESOLTIMING __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includePresol", 1); + + /* "src/pyscipopt/scip.pxi":3961 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludePresol(self._scip, n, d, priority, maxrounds, timing, PyPresolCopy, PyPresolFree, PyPresolInit, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3962 + * """ + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludePresol(self._scip, n, d, priority, maxrounds, timing, PyPresolCopy, PyPresolFree, PyPresolInit, + * PyPresolExit, PyPresolInitpre, PyPresolExitpre, PyPresolExec, presol)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_d = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3963 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludePresol(self._scip, n, d, priority, maxrounds, timing, PyPresolCopy, PyPresolFree, PyPresolInit, # <<<<<<<<<<<<<< + * PyPresolExit, PyPresolInitpre, PyPresolExitpre, PyPresolExec, presol)) + * presol.model = weakref.proxy(self) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 3963, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 3963, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3963, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_maxrounds); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3963, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_SCIP_PRESOLTIMING(__pyx_v_timing); if (unlikely((__pyx_t_8 == ((SCIP_PRESOLTIMING)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3963, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3964 + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludePresol(self._scip, n, d, priority, maxrounds, timing, PyPresolCopy, PyPresolFree, PyPresolInit, + * PyPresolExit, PyPresolInitpre, PyPresolExitpre, PyPresolExec, presol)) # <<<<<<<<<<<<<< + * presol.model = weakref.proxy(self) + * Py_INCREF(presol) + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludePresol(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_t_8, __pyx_f_9pyscipopt_4scip_PyPresolCopy, __pyx_f_9pyscipopt_4scip_PyPresolFree, __pyx_f_9pyscipopt_4scip_PyPresolInit, __pyx_f_9pyscipopt_4scip_PyPresolExit, __pyx_f_9pyscipopt_4scip_PyPresolInitpre, __pyx_f_9pyscipopt_4scip_PyPresolExitpre, __pyx_f_9pyscipopt_4scip_PyPresolExec, ((SCIP_PRESOLDATA *)__pyx_v_presol))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3965 + * PY_SCIP_CALL(SCIPincludePresol(self._scip, n, d, priority, maxrounds, timing, PyPresolCopy, PyPresolFree, PyPresolInit, + * PyPresolExit, PyPresolInitpre, PyPresolExitpre, PyPresolExec, presol)) + * presol.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * Py_INCREF(presol) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_presol->model); + __Pyx_DECREF((PyObject *)__pyx_v_presol->model); + __pyx_v_presol->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3966 + * PyPresolExit, PyPresolInitpre, PyPresolExitpre, PyPresolExec, presol)) + * presol.model = weakref.proxy(self) + * Py_INCREF(presol) # <<<<<<<<<<<<<< + * + * def includeSepa(self, Sepa sepa, name, desc, priority=0, freq=10, maxbounddist=1.0, usessubscip=False, delay=False): + */ + Py_INCREF(((PyObject *)__pyx_v_presol)); + + /* "src/pyscipopt/scip.pxi":3950 + * return constraint + * + * def includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=SCIP_PRESOLTIMING_FAST): # <<<<<<<<<<<<<< + * """Include a presolver + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.includePresol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3968 + * Py_INCREF(presol) + * + * def includeSepa(self, Sepa sepa, name, desc, priority=0, freq=10, maxbounddist=1.0, usessubscip=False, delay=False): # <<<<<<<<<<<<<< + * """Include a separator + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_427includeSepa(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_426includeSepa, "Model.includeSepa(self, Sepa sepa, name, desc, priority=0, freq=10, maxbounddist=1.0, usessubscip=False, delay=False)\nInclude a separator\n\n :param Sepa sepa: separator\n :param name: name of separator\n :param desc: description of separator\n :param priority: priority of separator (>= 0: before, < 0: after constraint handlers)\n :param freq: frequency for calling separator\n :param maxbounddist: maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation\n :param usessubscip: does the separator use a secondary SCIP instance? (Default value = False)\n :param delay: should separator be delayed, if other separators found cuts? (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_427includeSepa = {"includeSepa", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_427includeSepa, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_426includeSepa}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_427includeSepa(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_sepa = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_freq = 0; + PyObject *__pyx_v_maxbounddist = 0; + PyObject *__pyx_v_usessubscip = 0; + PyObject *__pyx_v_delay = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[8] = {0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeSepa (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sepa,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_priority,&__pyx_n_s_freq,&__pyx_n_s_maxbounddist,&__pyx_n_s_usessubscip,&__pyx_n_s_delay,0}; + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_0)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_10)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_float_1_0)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sepa)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeSepa", 0, 3, 8, 1); __PYX_ERR(0, 3968, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeSepa", 0, 3, 8, 2); __PYX_ERR(0, 3968, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_freq); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxbounddist); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_usessubscip); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_delay); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeSepa") < 0)) __PYX_ERR(0, 3968, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_sepa = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_priority = values[3]; + __pyx_v_freq = values[4]; + __pyx_v_maxbounddist = values[5]; + __pyx_v_usessubscip = values[6]; + __pyx_v_delay = values[7]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeSepa", 0, 3, 8, __pyx_nargs); __PYX_ERR(0, 3968, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeSepa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sepa), __pyx_ptype_9pyscipopt_4scip_Sepa, 1, "sepa", 0))) __PYX_ERR(0, 3968, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_426includeSepa(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_sepa, __pyx_v_name, __pyx_v_desc, __pyx_v_priority, __pyx_v_freq, __pyx_v_maxbounddist, __pyx_v_usessubscip, __pyx_v_delay); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_426includeSepa(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v_sepa, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_freq, PyObject *__pyx_v_maxbounddist, PyObject *__pyx_v_usessubscip, PyObject *__pyx_v_delay) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + int __pyx_t_7; + SCIP_Real __pyx_t_8; + SCIP_Bool __pyx_t_9; + SCIP_Bool __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeSepa", 1); + + /* "src/pyscipopt/scip.pxi":3981 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeSepa(self._scip, n, d, priority, freq, maxbounddist, usessubscip, delay, PySepaCopy, PySepaFree, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3981, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3981, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3982 + * """ + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeSepa(self._scip, n, d, priority, freq, maxbounddist, usessubscip, delay, PySepaCopy, PySepaFree, + * PySepaInit, PySepaExit, PySepaInitsol, PySepaExitsol, PySepaExeclp, PySepaExecsol, sepa)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3982, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3982, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_d = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3983 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeSepa(self._scip, n, d, priority, freq, maxbounddist, usessubscip, delay, PySepaCopy, PySepaFree, # <<<<<<<<<<<<<< + * PySepaInit, PySepaExit, PySepaInitsol, PySepaExitsol, PySepaExeclp, PySepaExecsol, sepa)) + * sepa.model = weakref.proxy(self) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 3983, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 3983, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3983, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_freq); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3983, __pyx_L1_error) + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_maxbounddist); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3983, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_usessubscip); if (unlikely((__pyx_t_9 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3983, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_delay); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 3983, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3984 + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeSepa(self._scip, n, d, priority, freq, maxbounddist, usessubscip, delay, PySepaCopy, PySepaFree, + * PySepaInit, PySepaExit, PySepaInitsol, PySepaExitsol, PySepaExeclp, PySepaExecsol, sepa)) # <<<<<<<<<<<<<< + * sepa.model = weakref.proxy(self) + * sepa.name = name + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeSepa(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_f_9pyscipopt_4scip_PySepaCopy, __pyx_f_9pyscipopt_4scip_PySepaFree, __pyx_f_9pyscipopt_4scip_PySepaInit, __pyx_f_9pyscipopt_4scip_PySepaExit, __pyx_f_9pyscipopt_4scip_PySepaInitsol, __pyx_f_9pyscipopt_4scip_PySepaExitsol, __pyx_f_9pyscipopt_4scip_PySepaExeclp, __pyx_f_9pyscipopt_4scip_PySepaExecsol, ((SCIP_SEPADATA *)__pyx_v_sepa))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_11 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3985 + * PY_SCIP_CALL(SCIPincludeSepa(self._scip, n, d, priority, freq, maxbounddist, usessubscip, delay, PySepaCopy, PySepaFree, + * PySepaInit, PySepaExit, PySepaInitsol, PySepaExitsol, PySepaExeclp, PySepaExecsol, sepa)) + * sepa.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * sepa.name = name + * Py_INCREF(sepa) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_sepa->model); + __Pyx_DECREF((PyObject *)__pyx_v_sepa->model); + __pyx_v_sepa->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3986 + * PySepaInit, PySepaExit, PySepaInitsol, PySepaExitsol, PySepaExeclp, PySepaExecsol, sepa)) + * sepa.model = weakref.proxy(self) + * sepa.name = name # <<<<<<<<<<<<<< + * Py_INCREF(sepa) + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(0, 3986, __pyx_L1_error) + __pyx_t_3 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_sepa->name); + __Pyx_DECREF(__pyx_v_sepa->name); + __pyx_v_sepa->name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":3987 + * sepa.model = weakref.proxy(self) + * sepa.name = name + * Py_INCREF(sepa) # <<<<<<<<<<<<<< + * + * def includeReader(self, Reader reader, name, desc, ext): + */ + Py_INCREF(((PyObject *)__pyx_v_sepa)); + + /* "src/pyscipopt/scip.pxi":3968 + * Py_INCREF(presol) + * + * def includeSepa(self, Sepa sepa, name, desc, priority=0, freq=10, maxbounddist=1.0, usessubscip=False, delay=False): # <<<<<<<<<<<<<< + * """Include a separator + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeSepa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":3989 + * Py_INCREF(sepa) + * + * def includeReader(self, Reader reader, name, desc, ext): # <<<<<<<<<<<<<< + * """Include a reader + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_429includeReader(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_428includeReader, "Model.includeReader(self, Reader reader, name, desc, ext)\nInclude a reader\n\n :param Reader reader: reader\n :param name: name of reader\n :param desc: description of reader\n :param ext: file extension of reader\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_429includeReader = {"includeReader", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_429includeReader, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_428includeReader}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_429includeReader(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_reader = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_ext = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeReader (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_reader,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_ext,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_reader)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3989, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3989, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeReader", 1, 4, 4, 1); __PYX_ERR(0, 3989, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3989, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeReader", 1, 4, 4, 2); __PYX_ERR(0, 3989, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ext)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3989, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeReader", 1, 4, 4, 3); __PYX_ERR(0, 3989, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeReader") < 0)) __PYX_ERR(0, 3989, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + } + __pyx_v_reader = ((struct __pyx_obj_9pyscipopt_4scip_Reader *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_ext = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeReader", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 3989, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeReader", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_reader), __pyx_ptype_9pyscipopt_4scip_Reader, 1, "reader", 0))) __PYX_ERR(0, 3989, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_428includeReader(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_reader, __pyx_v_name, __pyx_v_desc, __pyx_v_ext); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_428includeReader(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v_reader, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_ext) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_v_e = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + char const *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeReader", 1); + + /* "src/pyscipopt/scip.pxi":3998 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * e = str_conversion(ext) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3998, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3998, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":3999 + * """ + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * e = str_conversion(ext) + * PY_SCIP_CALL(SCIPincludeReader(self._scip, n, d, e, PyReaderCopy, PyReaderFree, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3999, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3999, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_d = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4000 + * n = str_conversion(name) + * d = str_conversion(desc) + * e = str_conversion(ext) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeReader(self._scip, n, d, e, PyReaderCopy, PyReaderFree, + * PyReaderRead, PyReaderWrite, reader)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_ext}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_e = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4001 + * d = str_conversion(desc) + * e = str_conversion(ext) + * PY_SCIP_CALL(SCIPincludeReader(self._scip, n, d, e, PyReaderCopy, PyReaderFree, # <<<<<<<<<<<<<< + * PyReaderRead, PyReaderWrite, reader)) + * reader.model = weakref.proxy(self) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4001, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 4001, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4001, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_e); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 4001, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4002 + * e = str_conversion(ext) + * PY_SCIP_CALL(SCIPincludeReader(self._scip, n, d, e, PyReaderCopy, PyReaderFree, + * PyReaderRead, PyReaderWrite, reader)) # <<<<<<<<<<<<<< + * reader.model = weakref.proxy(self) + * reader.name = name + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeReader(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_f_9pyscipopt_4scip_PyReaderCopy, __pyx_f_9pyscipopt_4scip_PyReaderFree, __pyx_f_9pyscipopt_4scip_PyReaderRead, __pyx_f_9pyscipopt_4scip_PyReaderWrite, ((SCIP_READERDATA *)__pyx_v_reader))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4001, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4001, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4003 + * PY_SCIP_CALL(SCIPincludeReader(self._scip, n, d, e, PyReaderCopy, PyReaderFree, + * PyReaderRead, PyReaderWrite, reader)) + * reader.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * reader.name = name + * Py_INCREF(reader) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4003, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4003, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4003, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_reader->model); + __Pyx_DECREF((PyObject *)__pyx_v_reader->model); + __pyx_v_reader->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4004 + * PyReaderRead, PyReaderWrite, reader)) + * reader.model = weakref.proxy(self) + * reader.name = name # <<<<<<<<<<<<<< + * Py_INCREF(reader) + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(0, 4004, __pyx_L1_error) + __pyx_t_3 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_reader->name); + __Pyx_DECREF(__pyx_v_reader->name); + __pyx_v_reader->name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4005 + * reader.model = weakref.proxy(self) + * reader.name = name + * Py_INCREF(reader) # <<<<<<<<<<<<<< + * + * def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds, + */ + Py_INCREF(((PyObject *)__pyx_v_reader)); + + /* "src/pyscipopt/scip.pxi":3989 + * Py_INCREF(sepa) + * + * def includeReader(self, Reader reader, name, desc, ext): # <<<<<<<<<<<<<< + * """Include a reader + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeReader", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XDECREF(__pyx_v_e); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4007 + * Py_INCREF(reader) + * + * def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds, # <<<<<<<<<<<<<< + * proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True): + * """Include a propagator. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_431includeProp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_430includeProp, "Model.includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds, proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True)\nInclude a propagator.\n\n :param Prop prop: propagator\n :param name: name of propagator\n :param desc: description of propagator\n :param presolpriority: presolving priority of the propgator (>= 0: before, < 0: after constraint handlers)\n :param presolmaxrounds: maximal number of presolving rounds the propagator participates in (-1: no limit)\n :param proptiming: positions in the node solving loop where propagation method of constraint handlers should be executed\n :param presoltiming: timing mask of the constraint handler's presolving method (Default value = SCIP_PRESOLTIMING_FAST)\n :param priority: priority of the propagator (Default value = 1)\n :param freq: frequency for calling propagator (Default value = 1)\n :param delay: should propagator be delayed if other propagators have found reductions? (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_431includeProp = {"includeProp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_431includeProp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_430includeProp}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_431includeProp(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_prop = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_presolpriority = 0; + PyObject *__pyx_v_presolmaxrounds = 0; + PyObject *__pyx_v_proptiming = 0; + PyObject *__pyx_v_presoltiming = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_freq = 0; + PyObject *__pyx_v_delay = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeProp (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_prop,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_presolpriority,&__pyx_n_s_presolmaxrounds,&__pyx_n_s_proptiming,&__pyx_n_s_presoltiming,&__pyx_n_s_priority,&__pyx_n_s_freq,&__pyx_n_s_delay,0}; + values[6] = __Pyx_Arg_NewRef_FASTCALL(__pyx_k__105); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_1)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_1)); + + /* "src/pyscipopt/scip.pxi":4008 + * + * def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds, + * proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True): # <<<<<<<<<<<<<< + * """Include a propagator. + * + */ + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_prop)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeProp", 0, 6, 10, 1); __PYX_ERR(0, 4007, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeProp", 0, 6, 10, 2); __PYX_ERR(0, 4007, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_presolpriority)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeProp", 0, 6, 10, 3); __PYX_ERR(0, 4007, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_presolmaxrounds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeProp", 0, 6, 10, 4); __PYX_ERR(0, 4007, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_proptiming)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[5]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeProp", 0, 6, 10, 5); __PYX_ERR(0, 4007, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_presoltiming); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_freq); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_delay); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4007, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeProp") < 0)) __PYX_ERR(0, 4007, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_prop = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_presolpriority = values[3]; + __pyx_v_presolmaxrounds = values[4]; + __pyx_v_proptiming = values[5]; + __pyx_v_presoltiming = values[6]; + __pyx_v_priority = values[7]; + __pyx_v_freq = values[8]; + __pyx_v_delay = values[9]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeProp", 0, 6, 10, __pyx_nargs); __PYX_ERR(0, 4007, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeProp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_prop), __pyx_ptype_9pyscipopt_4scip_Prop, 1, "prop", 0))) __PYX_ERR(0, 4007, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_430includeProp(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_prop, __pyx_v_name, __pyx_v_desc, __pyx_v_presolpriority, __pyx_v_presolmaxrounds, __pyx_v_proptiming, __pyx_v_presoltiming, __pyx_v_priority, __pyx_v_freq, __pyx_v_delay); + + /* "src/pyscipopt/scip.pxi":4007 + * Py_INCREF(reader) + * + * def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds, # <<<<<<<<<<<<<< + * proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True): + * """Include a propagator. + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_430includeProp(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v_prop, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_presolpriority, PyObject *__pyx_v_presolmaxrounds, PyObject *__pyx_v_proptiming, PyObject *__pyx_v_presoltiming, PyObject *__pyx_v_priority, PyObject *__pyx_v_freq, PyObject *__pyx_v_delay) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + int __pyx_t_7; + SCIP_Bool __pyx_t_8; + SCIP_PROPTIMING __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + SCIP_PRESOLTIMING __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeProp", 1); + + /* "src/pyscipopt/scip.pxi":4023 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeProp(self._scip, n, d, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4023, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4023, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4024 + * """ + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeProp(self._scip, n, d, + * priority, freq, delay, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_d = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4025 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeProp(self._scip, n, d, # <<<<<<<<<<<<<< + * priority, freq, delay, + * proptiming, presolpriority, presolmaxrounds, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 4025, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4025, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4026 + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeProp(self._scip, n, d, + * priority, freq, delay, # <<<<<<<<<<<<<< + * proptiming, presolpriority, presolmaxrounds, + * presoltiming, PyPropCopy, PyPropFree, PyPropInit, PyPropExit, + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4026, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_freq); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4026, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_delay); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4026, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4027 + * PY_SCIP_CALL(SCIPincludeProp(self._scip, n, d, + * priority, freq, delay, + * proptiming, presolpriority, presolmaxrounds, # <<<<<<<<<<<<<< + * presoltiming, PyPropCopy, PyPropFree, PyPropInit, PyPropExit, + * PyPropInitpre, PyPropExitpre, PyPropInitsol, PyPropExitsol, + */ + __pyx_t_9 = __Pyx_PyInt_As_SCIP_PROPTIMING(__pyx_v_proptiming); if (unlikely((__pyx_t_9 == ((SCIP_PROPTIMING)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4027, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_presolpriority); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4027, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_v_presolmaxrounds); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4027, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4028 + * priority, freq, delay, + * proptiming, presolpriority, presolmaxrounds, + * presoltiming, PyPropCopy, PyPropFree, PyPropInit, PyPropExit, # <<<<<<<<<<<<<< + * PyPropInitpre, PyPropExitpre, PyPropInitsol, PyPropExitsol, + * PyPropPresol, PyPropExec, PyPropResProp, + */ + __pyx_t_12 = __Pyx_PyInt_As_SCIP_PRESOLTIMING(__pyx_v_presoltiming); if (unlikely((__pyx_t_12 == ((SCIP_PRESOLTIMING)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4028, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4025 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeProp(self._scip, n, d, # <<<<<<<<<<<<<< + * priority, freq, delay, + * proptiming, presolpriority, presolmaxrounds, + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeProp(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_f_9pyscipopt_4scip_PyPropCopy, __pyx_f_9pyscipopt_4scip_PyPropFree, __pyx_f_9pyscipopt_4scip_PyPropInit, __pyx_f_9pyscipopt_4scip_PyPropExit, __pyx_f_9pyscipopt_4scip_PyPropInitpre, __pyx_f_9pyscipopt_4scip_PyPropExitpre, __pyx_f_9pyscipopt_4scip_PyPropInitsol, __pyx_f_9pyscipopt_4scip_PyPropExitsol, __pyx_f_9pyscipopt_4scip_PyPropPresol, __pyx_f_9pyscipopt_4scip_PyPropExec, __pyx_f_9pyscipopt_4scip_PyPropResProp, ((SCIP_PROPDATA *)__pyx_v_prop))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4025, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4032 + * PyPropPresol, PyPropExec, PyPropResProp, + * prop)) + * prop.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * Py_INCREF(prop) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4032, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4032, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4032, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_prop->model); + __Pyx_DECREF((PyObject *)__pyx_v_prop->model); + __pyx_v_prop->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4033 + * prop)) + * prop.model = weakref.proxy(self) + * Py_INCREF(prop) # <<<<<<<<<<<<<< + * + * def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0, + */ + Py_INCREF(((PyObject *)__pyx_v_prop)); + + /* "src/pyscipopt/scip.pxi":4007 + * Py_INCREF(reader) + * + * def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds, # <<<<<<<<<<<<<< + * proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True): + * """Include a propagator. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeProp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4035 + * Py_INCREF(prop) + * + * def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0, # <<<<<<<<<<<<<< + * maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False): + * """Include a primal heuristic. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_433includeHeur(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_432includeHeur, "Model.includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0, maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False)\nInclude a primal heuristic.\n\n :param Heur heur: heuristic\n :param name: name of heuristic\n :param desc: description of heuristic\n :param dispchar: display character of heuristic\n :param priority: priority of the heuristic (Default value = 10000)\n :param freq: frequency for calling heuristic (Default value = 1)\n :param freqofs: frequency offset for calling heuristic (Default value = 0)\n :param maxdepth: maximal depth level to call heuristic at (Default value = -1)\n :param timingmask: positions in the node solving loop where heuristic should be executed (Default value = SCIP_HEURTIMING_BEFORENODE)\n :param usessubscip: does the heuristic use a secondary SCIP instance? (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_433includeHeur = {"includeHeur", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_433includeHeur, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_432includeHeur}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_433includeHeur(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_dispchar = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_freq = 0; + PyObject *__pyx_v_freqofs = 0; + PyObject *__pyx_v_maxdepth = 0; + PyObject *__pyx_v_timingmask = 0; + PyObject *__pyx_v_usessubscip = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeHeur (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_heur,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_dispchar,&__pyx_n_s_priority,&__pyx_n_s_freq,&__pyx_n_s_freqofs,&__pyx_n_s_maxdepth,&__pyx_n_s_timingmask,&__pyx_n_s_usessubscip,0}; + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_10000)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_1)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_0)); + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_neg_1)); + values[8] = __Pyx_Arg_NewRef_FASTCALL(__pyx_k__106); + + /* "src/pyscipopt/scip.pxi":4036 + * + * def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0, + * maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False): # <<<<<<<<<<<<<< + * """Include a primal heuristic. + * + */ + values[9] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_heur)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeHeur", 0, 4, 10, 1); __PYX_ERR(0, 4035, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeHeur", 0, 4, 10, 2); __PYX_ERR(0, 4035, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dispchar)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeHeur", 0, 4, 10, 3); __PYX_ERR(0, 4035, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_freq); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_freqofs); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxdepth); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 8: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_timingmask); + if (value) { values[8] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 9: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_usessubscip); + if (value) { values[9] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4035, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeHeur") < 0)) __PYX_ERR(0, 4035, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 10: values[9] = __Pyx_Arg_FASTCALL(__pyx_args, 9); + CYTHON_FALLTHROUGH; + case 9: values[8] = __Pyx_Arg_FASTCALL(__pyx_args, 8); + CYTHON_FALLTHROUGH; + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_heur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_dispchar = values[3]; + __pyx_v_priority = values[4]; + __pyx_v_freq = values[5]; + __pyx_v_freqofs = values[6]; + __pyx_v_maxdepth = values[7]; + __pyx_v_timingmask = values[8]; + __pyx_v_usessubscip = values[9]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeHeur", 0, 4, 10, __pyx_nargs); __PYX_ERR(0, 4035, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeHeur", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_heur), __pyx_ptype_9pyscipopt_4scip_Heur, 1, "heur", 0))) __PYX_ERR(0, 4035, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_432includeHeur(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_heur, __pyx_v_name, __pyx_v_desc, __pyx_v_dispchar, __pyx_v_priority, __pyx_v_freq, __pyx_v_freqofs, __pyx_v_maxdepth, __pyx_v_timingmask, __pyx_v_usessubscip); + + /* "src/pyscipopt/scip.pxi":4035 + * Py_INCREF(prop) + * + * def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0, # <<<<<<<<<<<<<< + * maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False): + * """Include a primal heuristic. + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_432includeHeur(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_dispchar, PyObject *__pyx_v_priority, PyObject *__pyx_v_freq, PyObject *__pyx_v_freqofs, PyObject *__pyx_v_maxdepth, PyObject *__pyx_v_timingmask, PyObject *__pyx_v_usessubscip) { + PyObject *__pyx_v_nam = NULL; + PyObject *__pyx_v_des = NULL; + long __pyx_v_dis; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + long __pyx_t_5; + char const *__pyx_t_6; + char const *__pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + unsigned int __pyx_t_11; + SCIP_Bool __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeHeur", 1); + + /* "src/pyscipopt/scip.pxi":4051 + * + * """ + * nam = str_conversion(name) # <<<<<<<<<<<<<< + * des = str_conversion(desc) + * dis = ord(str_conversion(dispchar)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4051, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4051, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_nam = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4052 + * """ + * nam = str_conversion(name) + * des = str_conversion(desc) # <<<<<<<<<<<<<< + * dis = ord(str_conversion(dispchar)) + * PY_SCIP_CALL(SCIPincludeHeur(self._scip, nam, des, dis, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4052, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4052, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_des = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4053 + * nam = str_conversion(name) + * des = str_conversion(desc) + * dis = ord(str_conversion(dispchar)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeHeur(self._scip, nam, des, dis, + * priority, freq, freqofs, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4053, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_dispchar}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4053, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyObject_Ord(__pyx_t_1); if (unlikely(__pyx_t_5 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 4053, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_dis = __pyx_t_5; + + /* "src/pyscipopt/scip.pxi":4054 + * des = str_conversion(desc) + * dis = ord(str_conversion(dispchar)) + * PY_SCIP_CALL(SCIPincludeHeur(self._scip, nam, des, dis, # <<<<<<<<<<<<<< + * priority, freq, freqofs, + * maxdepth, timingmask, usessubscip, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_nam); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4054, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_des); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 4054, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4055 + * dis = ord(str_conversion(dispchar)) + * PY_SCIP_CALL(SCIPincludeHeur(self._scip, nam, des, dis, + * priority, freq, freqofs, # <<<<<<<<<<<<<< + * maxdepth, timingmask, usessubscip, + * PyHeurCopy, PyHeurFree, PyHeurInit, PyHeurExit, + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4055, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_freq); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4055, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_freqofs); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4055, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4056 + * PY_SCIP_CALL(SCIPincludeHeur(self._scip, nam, des, dis, + * priority, freq, freqofs, + * maxdepth, timingmask, usessubscip, # <<<<<<<<<<<<<< + * PyHeurCopy, PyHeurFree, PyHeurInit, PyHeurExit, + * PyHeurInitsol, PyHeurExitsol, PyHeurExec, + */ + __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_maxdepth); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4056, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyInt_As_unsigned_int(__pyx_v_timingmask); if (unlikely((__pyx_t_11 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4056, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_usessubscip); if (unlikely((__pyx_t_12 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4056, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4054 + * des = str_conversion(desc) + * dis = ord(str_conversion(dispchar)) + * PY_SCIP_CALL(SCIPincludeHeur(self._scip, nam, des, dis, # <<<<<<<<<<<<<< + * priority, freq, freqofs, + * maxdepth, timingmask, usessubscip, + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeHeur(__pyx_v_self->_scip, __pyx_t_6, __pyx_t_7, __pyx_v_dis, __pyx_t_4, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_f_9pyscipopt_4scip_PyHeurCopy, __pyx_f_9pyscipopt_4scip_PyHeurFree, __pyx_f_9pyscipopt_4scip_PyHeurInit, __pyx_f_9pyscipopt_4scip_PyHeurExit, __pyx_f_9pyscipopt_4scip_PyHeurInitsol, __pyx_f_9pyscipopt_4scip_PyHeurExitsol, __pyx_f_9pyscipopt_4scip_PyHeurExec, ((SCIP_HEURDATA *)__pyx_v_heur))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4060 + * PyHeurInitsol, PyHeurExitsol, PyHeurExec, + * heur)) + * heur.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * heur.name = name + * Py_INCREF(heur) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_10 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_10 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_10, 1+__pyx_t_10); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4060, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_heur->model); + __Pyx_DECREF((PyObject *)__pyx_v_heur->model); + __pyx_v_heur->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4061 + * heur)) + * heur.model = weakref.proxy(self) + * heur.name = name # <<<<<<<<<<<<<< + * Py_INCREF(heur) + * + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(0, 4061, __pyx_L1_error) + __pyx_t_3 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_heur->name); + __Pyx_DECREF(__pyx_v_heur->name); + __pyx_v_heur->name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4062 + * heur.model = weakref.proxy(self) + * heur.name = name + * Py_INCREF(heur) # <<<<<<<<<<<<<< + * + * def includeRelax(self, Relax relax, name, desc, priority=10000, freq=1): + */ + Py_INCREF(((PyObject *)__pyx_v_heur)); + + /* "src/pyscipopt/scip.pxi":4035 + * Py_INCREF(prop) + * + * def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0, # <<<<<<<<<<<<<< + * maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False): + * """Include a primal heuristic. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeHeur", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nam); + __Pyx_XDECREF(__pyx_v_des); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4064 + * Py_INCREF(heur) + * + * def includeRelax(self, Relax relax, name, desc, priority=10000, freq=1): # <<<<<<<<<<<<<< + * """Include a relaxation handler. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_435includeRelax(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_434includeRelax, "Model.includeRelax(self, Relax relax, name, desc, priority=10000, freq=1)\nInclude a relaxation handler.\n\n :param Relax relax: relaxation handler\n :param name: name of relaxation handler\n :param desc: description of relaxation handler\n :param priority: priority of the relaxation handler (negative: after LP, non-negative: before LP, Default value = 10000)\n :param freq: frequency for calling relaxation handler\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_435includeRelax = {"includeRelax", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_435includeRelax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_434includeRelax}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_435includeRelax(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_relax = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_freq = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeRelax (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_relax,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_priority,&__pyx_n_s_freq,0}; + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_10000)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_1)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_relax)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4064, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4064, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeRelax", 0, 3, 5, 1); __PYX_ERR(0, 4064, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4064, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeRelax", 0, 3, 5, 2); __PYX_ERR(0, 4064, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4064, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_freq); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4064, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeRelax") < 0)) __PYX_ERR(0, 4064, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_relax = ((struct __pyx_obj_9pyscipopt_4scip_Relax *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_priority = values[3]; + __pyx_v_freq = values[4]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeRelax", 0, 3, 5, __pyx_nargs); __PYX_ERR(0, 4064, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeRelax", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_relax), __pyx_ptype_9pyscipopt_4scip_Relax, 1, "relax", 0))) __PYX_ERR(0, 4064, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_434includeRelax(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_relax, __pyx_v_name, __pyx_v_desc, __pyx_v_priority, __pyx_v_freq); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_434includeRelax(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v_relax, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_freq) { + PyObject *__pyx_v_nam = NULL; + PyObject *__pyx_v_des = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeRelax", 1); + + /* "src/pyscipopt/scip.pxi":4074 + * + * """ + * nam = str_conversion(name) # <<<<<<<<<<<<<< + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeRelax(self._scip, nam, des, priority, freq, PyRelaxCopy, PyRelaxFree, PyRelaxInit, PyRelaxExit, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4074, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4074, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_nam = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4075 + * """ + * nam = str_conversion(name) + * des = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeRelax(self._scip, nam, des, priority, freq, PyRelaxCopy, PyRelaxFree, PyRelaxInit, PyRelaxExit, + * PyRelaxInitsol, PyRelaxExitsol, PyRelaxExec, relax)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4075, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4075, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_des = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4076 + * nam = str_conversion(name) + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeRelax(self._scip, nam, des, priority, freq, PyRelaxCopy, PyRelaxFree, PyRelaxInit, PyRelaxExit, # <<<<<<<<<<<<<< + * PyRelaxInitsol, PyRelaxExitsol, PyRelaxExec, relax)) + * relax.model = weakref.proxy(self) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_nam); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 4076, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_des); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4076, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4076, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_freq); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4076, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4077 + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeRelax(self._scip, nam, des, priority, freq, PyRelaxCopy, PyRelaxFree, PyRelaxInit, PyRelaxExit, + * PyRelaxInitsol, PyRelaxExitsol, PyRelaxExec, relax)) # <<<<<<<<<<<<<< + * relax.model = weakref.proxy(self) + * relax.name = name + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeRelax(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_f_9pyscipopt_4scip_PyRelaxCopy, __pyx_f_9pyscipopt_4scip_PyRelaxFree, __pyx_f_9pyscipopt_4scip_PyRelaxInit, __pyx_f_9pyscipopt_4scip_PyRelaxExit, __pyx_f_9pyscipopt_4scip_PyRelaxInitsol, __pyx_f_9pyscipopt_4scip_PyRelaxExitsol, __pyx_f_9pyscipopt_4scip_PyRelaxExec, ((SCIP_RELAXDATA *)__pyx_v_relax))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4078 + * PY_SCIP_CALL(SCIPincludeRelax(self._scip, nam, des, priority, freq, PyRelaxCopy, PyRelaxFree, PyRelaxInit, PyRelaxExit, + * PyRelaxInitsol, PyRelaxExitsol, PyRelaxExec, relax)) + * relax.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * relax.name = name + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_relax->model); + __Pyx_DECREF((PyObject *)__pyx_v_relax->model); + __pyx_v_relax->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4079 + * PyRelaxInitsol, PyRelaxExitsol, PyRelaxExec, relax)) + * relax.model = weakref.proxy(self) + * relax.name = name # <<<<<<<<<<<<<< + * + * Py_INCREF(relax) + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(0, 4079, __pyx_L1_error) + __pyx_t_3 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_relax->name); + __Pyx_DECREF(__pyx_v_relax->name); + __pyx_v_relax->name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4081 + * relax.name = name + * + * Py_INCREF(relax) # <<<<<<<<<<<<<< + * + * def includeCutsel(self, Cutsel cutsel, name, desc, priority): + */ + Py_INCREF(((PyObject *)__pyx_v_relax)); + + /* "src/pyscipopt/scip.pxi":4064 + * Py_INCREF(heur) + * + * def includeRelax(self, Relax relax, name, desc, priority=10000, freq=1): # <<<<<<<<<<<<<< + * """Include a relaxation handler. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeRelax", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nam); + __Pyx_XDECREF(__pyx_v_des); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4083 + * Py_INCREF(relax) + * + * def includeCutsel(self, Cutsel cutsel, name, desc, priority): # <<<<<<<<<<<<<< + * """include a cut selector + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_437includeCutsel(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_436includeCutsel, "Model.includeCutsel(self, Cutsel cutsel, name, desc, priority)\ninclude a cut selector\n\n :param Cutsel cutsel: cut selector\n :param name: name of cut selector\n :param desc: description of cut selector\n :param priority: priority of the cut selector\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_437includeCutsel = {"includeCutsel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_437includeCutsel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_436includeCutsel}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_437includeCutsel(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_cutsel = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_priority = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeCutsel (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cutsel,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_priority,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cutsel)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4083, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4083, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeCutsel", 1, 4, 4, 1); __PYX_ERR(0, 4083, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4083, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeCutsel", 1, 4, 4, 2); __PYX_ERR(0, 4083, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4083, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeCutsel", 1, 4, 4, 3); __PYX_ERR(0, 4083, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeCutsel") < 0)) __PYX_ERR(0, 4083, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + } + __pyx_v_cutsel = ((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_priority = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeCutsel", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 4083, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeCutsel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cutsel), __pyx_ptype_9pyscipopt_4scip_Cutsel, 1, "cutsel", 0))) __PYX_ERR(0, 4083, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_436includeCutsel(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_cutsel, __pyx_v_name, __pyx_v_desc, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_436includeCutsel(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v_cutsel, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority) { + PyObject *__pyx_v_nam = NULL; + PyObject *__pyx_v_des = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeCutsel", 1); + + /* "src/pyscipopt/scip.pxi":4092 + * """ + * + * nam = str_conversion(name) # <<<<<<<<<<<<<< + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeCutsel(self._scip, nam, des, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_nam = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4093 + * + * nam = str_conversion(name) + * des = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeCutsel(self._scip, nam, des, + * priority, PyCutselCopy, PyCutselFree, PyCutselInit, PyCutselExit, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_des = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4094 + * nam = str_conversion(name) + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeCutsel(self._scip, nam, des, # <<<<<<<<<<<<<< + * priority, PyCutselCopy, PyCutselFree, PyCutselInit, PyCutselExit, + * PyCutselInitsol, PyCutselExitsol, PyCutselSelect, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_nam); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 4094, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_des); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4094, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4095 + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeCutsel(self._scip, nam, des, + * priority, PyCutselCopy, PyCutselFree, PyCutselInit, PyCutselExit, # <<<<<<<<<<<<<< + * PyCutselInitsol, PyCutselExitsol, PyCutselSelect, + * cutsel)) + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4095, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4094 + * nam = str_conversion(name) + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeCutsel(self._scip, nam, des, # <<<<<<<<<<<<<< + * priority, PyCutselCopy, PyCutselFree, PyCutselInit, PyCutselExit, + * PyCutselInitsol, PyCutselExitsol, PyCutselSelect, + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeCutsel(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_f_9pyscipopt_4scip_PyCutselCopy, __pyx_f_9pyscipopt_4scip_PyCutselFree, __pyx_f_9pyscipopt_4scip_PyCutselInit, __pyx_f_9pyscipopt_4scip_PyCutselExit, __pyx_f_9pyscipopt_4scip_PyCutselInitsol, __pyx_f_9pyscipopt_4scip_PyCutselExitsol, __pyx_f_9pyscipopt_4scip_PyCutselSelect, ((SCIP_CUTSELDATA *)__pyx_v_cutsel))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4098 + * PyCutselInitsol, PyCutselExitsol, PyCutselSelect, + * cutsel)) + * cutsel.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * Py_INCREF(cutsel) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4098, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4098, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4098, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_cutsel->model); + __Pyx_DECREF((PyObject *)__pyx_v_cutsel->model); + __pyx_v_cutsel->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4099 + * cutsel)) + * cutsel.model = weakref.proxy(self) + * Py_INCREF(cutsel) # <<<<<<<<<<<<<< + * + * def includeBranchrule(self, Branchrule branchrule, name, desc, priority, maxdepth, maxbounddist): + */ + Py_INCREF(((PyObject *)__pyx_v_cutsel)); + + /* "src/pyscipopt/scip.pxi":4083 + * Py_INCREF(relax) + * + * def includeCutsel(self, Cutsel cutsel, name, desc, priority): # <<<<<<<<<<<<<< + * """include a cut selector + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeCutsel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nam); + __Pyx_XDECREF(__pyx_v_des); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4101 + * Py_INCREF(cutsel) + * + * def includeBranchrule(self, Branchrule branchrule, name, desc, priority, maxdepth, maxbounddist): # <<<<<<<<<<<<<< + * """Include a branching rule. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_439includeBranchrule(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_438includeBranchrule, "Model.includeBranchrule(self, Branchrule branchrule, name, desc, priority, maxdepth, maxbounddist)\nInclude a branching rule.\n\n :param Branchrule branchrule: branching rule\n :param name: name of branching rule\n :param desc: description of branching rule\n :param priority: priority of branching rule\n :param maxdepth: maximal depth level up to which this branching rule should be used (or -1)\n :param maxbounddist: maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_439includeBranchrule = {"includeBranchrule", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_439includeBranchrule, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_438includeBranchrule}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_439includeBranchrule(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_branchrule = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_maxdepth = 0; + PyObject *__pyx_v_maxbounddist = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[6] = {0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeBranchrule (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_branchrule,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_priority,&__pyx_n_s_maxdepth,&__pyx_n_s_maxbounddist,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_branchrule)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4101, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4101, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBranchrule", 1, 6, 6, 1); __PYX_ERR(0, 4101, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4101, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBranchrule", 1, 6, 6, 2); __PYX_ERR(0, 4101, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4101, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBranchrule", 1, 6, 6, 3); __PYX_ERR(0, 4101, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxdepth)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4101, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBranchrule", 1, 6, 6, 4); __PYX_ERR(0, 4101, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (likely((values[5] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxbounddist)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[5]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4101, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBranchrule", 1, 6, 6, 5); __PYX_ERR(0, 4101, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeBranchrule") < 0)) __PYX_ERR(0, 4101, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 6)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + } + __pyx_v_branchrule = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_priority = values[3]; + __pyx_v_maxdepth = values[4]; + __pyx_v_maxbounddist = values[5]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeBranchrule", 1, 6, 6, __pyx_nargs); __PYX_ERR(0, 4101, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeBranchrule", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_branchrule), __pyx_ptype_9pyscipopt_4scip_Branchrule, 1, "branchrule", 0))) __PYX_ERR(0, 4101, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_438includeBranchrule(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_branchrule, __pyx_v_name, __pyx_v_desc, __pyx_v_priority, __pyx_v_maxdepth, __pyx_v_maxbounddist); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_438includeBranchrule(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v_branchrule, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_maxdepth, PyObject *__pyx_v_maxbounddist) { + PyObject *__pyx_v_nam = NULL; + PyObject *__pyx_v_des = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + int __pyx_t_7; + SCIP_Real __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeBranchrule", 1); + + /* "src/pyscipopt/scip.pxi":4112 + * + * """ + * nam = str_conversion(name) # <<<<<<<<<<<<<< + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBranchrule(self._scip, nam, des, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_nam = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4113 + * """ + * nam = str_conversion(name) + * des = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeBranchrule(self._scip, nam, des, + * priority, maxdepth, maxbounddist, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_des = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4114 + * nam = str_conversion(name) + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBranchrule(self._scip, nam, des, # <<<<<<<<<<<<<< + * priority, maxdepth, maxbounddist, + * PyBranchruleCopy, PyBranchruleFree, PyBranchruleInit, PyBranchruleExit, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_nam); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 4114, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_des); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4114, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4115 + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBranchrule(self._scip, nam, des, + * priority, maxdepth, maxbounddist, # <<<<<<<<<<<<<< + * PyBranchruleCopy, PyBranchruleFree, PyBranchruleInit, PyBranchruleExit, + * PyBranchruleInitsol, PyBranchruleExitsol, PyBranchruleExeclp, PyBranchruleExecext, + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4115, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_maxdepth); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4115, __pyx_L1_error) + __pyx_t_8 = __pyx_PyFloat_AsDouble(__pyx_v_maxbounddist); if (unlikely((__pyx_t_8 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4115, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4114 + * nam = str_conversion(name) + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBranchrule(self._scip, nam, des, # <<<<<<<<<<<<<< + * priority, maxdepth, maxbounddist, + * PyBranchruleCopy, PyBranchruleFree, PyBranchruleInit, PyBranchruleExit, + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeBranchrule(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_t_8, __pyx_f_9pyscipopt_4scip_PyBranchruleCopy, __pyx_f_9pyscipopt_4scip_PyBranchruleFree, __pyx_f_9pyscipopt_4scip_PyBranchruleInit, __pyx_f_9pyscipopt_4scip_PyBranchruleExit, __pyx_f_9pyscipopt_4scip_PyBranchruleInitsol, __pyx_f_9pyscipopt_4scip_PyBranchruleExitsol, __pyx_f_9pyscipopt_4scip_PyBranchruleExeclp, __pyx_f_9pyscipopt_4scip_PyBranchruleExecext, __pyx_f_9pyscipopt_4scip_PyBranchruleExecps, ((SCIP_BRANCHRULEDATA *)__pyx_v_branchrule))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4119 + * PyBranchruleInitsol, PyBranchruleExitsol, PyBranchruleExeclp, PyBranchruleExecext, + * PyBranchruleExecps, branchrule)) + * branchrule.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * Py_INCREF(branchrule) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_branchrule->model); + __Pyx_DECREF((PyObject *)__pyx_v_branchrule->model); + __pyx_v_branchrule->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4120 + * PyBranchruleExecps, branchrule)) + * branchrule.model = weakref.proxy(self) + * Py_INCREF(branchrule) # <<<<<<<<<<<<<< + * + * def includeNodesel(self, Nodesel nodesel, name, desc, stdpriority, memsavepriority): + */ + Py_INCREF(((PyObject *)__pyx_v_branchrule)); + + /* "src/pyscipopt/scip.pxi":4101 + * Py_INCREF(cutsel) + * + * def includeBranchrule(self, Branchrule branchrule, name, desc, priority, maxdepth, maxbounddist): # <<<<<<<<<<<<<< + * """Include a branching rule. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeBranchrule", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nam); + __Pyx_XDECREF(__pyx_v_des); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4122 + * Py_INCREF(branchrule) + * + * def includeNodesel(self, Nodesel nodesel, name, desc, stdpriority, memsavepriority): # <<<<<<<<<<<<<< + * """Include a node selector. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_441includeNodesel(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_440includeNodesel, "Model.includeNodesel(self, Nodesel nodesel, name, desc, stdpriority, memsavepriority)\nInclude a node selector.\n\n :param Nodesel nodesel: node selector\n :param name: name of node selector\n :param desc: description of node selector\n :param stdpriority: priority of the node selector in standard mode\n :param memsavepriority: priority of the node selector in memory saving mode\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_441includeNodesel = {"includeNodesel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_441includeNodesel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_440includeNodesel}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_441includeNodesel(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_nodesel = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_stdpriority = 0; + PyObject *__pyx_v_memsavepriority = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeNodesel (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nodesel,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_stdpriority,&__pyx_n_s_memsavepriority,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nodesel)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4122, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4122, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeNodesel", 1, 5, 5, 1); __PYX_ERR(0, 4122, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4122, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeNodesel", 1, 5, 5, 2); __PYX_ERR(0, 4122, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stdpriority)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4122, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeNodesel", 1, 5, 5, 3); __PYX_ERR(0, 4122, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (likely((values[4] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_memsavepriority)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[4]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4122, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeNodesel", 1, 5, 5, 4); __PYX_ERR(0, 4122, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeNodesel") < 0)) __PYX_ERR(0, 4122, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 5)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + } + __pyx_v_nodesel = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_stdpriority = values[3]; + __pyx_v_memsavepriority = values[4]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeNodesel", 1, 5, 5, __pyx_nargs); __PYX_ERR(0, 4122, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeNodesel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_nodesel), __pyx_ptype_9pyscipopt_4scip_Nodesel, 1, "nodesel", 0))) __PYX_ERR(0, 4122, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_440includeNodesel(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_nodesel, __pyx_v_name, __pyx_v_desc, __pyx_v_stdpriority, __pyx_v_memsavepriority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_440includeNodesel(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v_nodesel, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_stdpriority, PyObject *__pyx_v_memsavepriority) { + PyObject *__pyx_v_nam = NULL; + PyObject *__pyx_v_des = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeNodesel", 1); + + /* "src/pyscipopt/scip.pxi":4132 + * + * """ + * nam = str_conversion(name) # <<<<<<<<<<<<<< + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeNodesel(self._scip, nam, des, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_nam = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4133 + * """ + * nam = str_conversion(name) + * des = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeNodesel(self._scip, nam, des, + * stdpriority, memsavepriority, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4133, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_des = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4134 + * nam = str_conversion(name) + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeNodesel(self._scip, nam, des, # <<<<<<<<<<<<<< + * stdpriority, memsavepriority, + * PyNodeselCopy, PyNodeselFree, PyNodeselInit, PyNodeselExit, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_nam); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 4134, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_des); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4134, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4135 + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeNodesel(self._scip, nam, des, + * stdpriority, memsavepriority, # <<<<<<<<<<<<<< + * PyNodeselCopy, PyNodeselFree, PyNodeselInit, PyNodeselExit, + * PyNodeselInitsol, PyNodeselExitsol, PyNodeselSelect, PyNodeselComp, + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_stdpriority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4135, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_memsavepriority); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4135, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4134 + * nam = str_conversion(name) + * des = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeNodesel(self._scip, nam, des, # <<<<<<<<<<<<<< + * stdpriority, memsavepriority, + * PyNodeselCopy, PyNodeselFree, PyNodeselInit, PyNodeselExit, + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeNodesel(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_f_9pyscipopt_4scip_PyNodeselCopy, __pyx_f_9pyscipopt_4scip_PyNodeselFree, __pyx_f_9pyscipopt_4scip_PyNodeselInit, __pyx_f_9pyscipopt_4scip_PyNodeselExit, __pyx_f_9pyscipopt_4scip_PyNodeselInitsol, __pyx_f_9pyscipopt_4scip_PyNodeselExitsol, __pyx_f_9pyscipopt_4scip_PyNodeselSelect, __pyx_f_9pyscipopt_4scip_PyNodeselComp, ((SCIP_NODESELDATA *)__pyx_v_nodesel))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4139 + * PyNodeselInitsol, PyNodeselExitsol, PyNodeselSelect, PyNodeselComp, + * nodesel)) + * nodesel.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * Py_INCREF(nodesel) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_nodesel->model); + __Pyx_DECREF((PyObject *)__pyx_v_nodesel->model); + __pyx_v_nodesel->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4140 + * nodesel)) + * nodesel.model = weakref.proxy(self) + * Py_INCREF(nodesel) # <<<<<<<<<<<<<< + * + * def includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True, + */ + Py_INCREF(((PyObject *)__pyx_v_nodesel)); + + /* "src/pyscipopt/scip.pxi":4122 + * Py_INCREF(branchrule) + * + * def includeNodesel(self, Nodesel nodesel, name, desc, stdpriority, memsavepriority): # <<<<<<<<<<<<<< + * """Include a node selector. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeNodesel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_nam); + __Pyx_XDECREF(__pyx_v_des); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4142 + * Py_INCREF(nodesel) + * + * def includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True, # <<<<<<<<<<<<<< + * shareaux=False): + * """Include a Benders' decomposition. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_443includeBenders(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_442includeBenders, "Model.includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True, shareaux=False)\nInclude a Benders' decomposition.\n\n Keyword arguments:\n benders -- the Benders decomposition\n name -- the name\n desc -- the description\n priority -- priority of the Benders' decomposition\n cutlp -- should Benders' cuts be generated from LP solutions\n cutpseudo -- should Benders' cuts be generated from pseudo solutions\n cutrelax -- should Benders' cuts be generated from relaxation solutions\n shareaux -- should the Benders' decomposition share the auxiliary variables of the highest priority Benders' decomposition\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_443includeBenders = {"includeBenders", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_443includeBenders, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_442includeBenders}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_443includeBenders(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_cutlp = 0; + PyObject *__pyx_v_cutpseudo = 0; + PyObject *__pyx_v_cutrelax = 0; + PyObject *__pyx_v_shareaux = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[8] = {0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeBenders (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_benders,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_priority,&__pyx_n_s_cutlp,&__pyx_n_s_cutpseudo,&__pyx_n_s_cutrelax,&__pyx_n_s_shareaux,0}; + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_1)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + + /* "src/pyscipopt/scip.pxi":4143 + * + * def includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True, + * shareaux=False): # <<<<<<<<<<<<<< + * """Include a Benders' decomposition. + * + */ + values[7] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4142, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4142, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBenders", 0, 3, 8, 1); __PYX_ERR(0, 4142, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4142, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBenders", 0, 3, 8, 2); __PYX_ERR(0, 4142, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4142, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cutlp); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4142, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cutpseudo); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4142, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cutrelax); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4142, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 7: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_shareaux); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4142, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeBenders") < 0)) __PYX_ERR(0, 4142, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); + CYTHON_FALLTHROUGH; + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[0]); + __pyx_v_name = values[1]; + __pyx_v_desc = values[2]; + __pyx_v_priority = values[3]; + __pyx_v_cutlp = values[4]; + __pyx_v_cutpseudo = values[5]; + __pyx_v_cutrelax = values[6]; + __pyx_v_shareaux = values[7]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeBenders", 0, 3, 8, __pyx_nargs); __PYX_ERR(0, 4142, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeBenders", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 4142, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_442includeBenders(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_benders, __pyx_v_name, __pyx_v_desc, __pyx_v_priority, __pyx_v_cutlp, __pyx_v_cutpseudo, __pyx_v_cutrelax, __pyx_v_shareaux); + + /* "src/pyscipopt/scip.pxi":4142 + * Py_INCREF(nodesel) + * + * def includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True, # <<<<<<<<<<<<<< + * shareaux=False): + * """Include a Benders' decomposition. + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_442includeBenders(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_cutlp, PyObject *__pyx_v_cutpseudo, PyObject *__pyx_v_cutrelax, PyObject *__pyx_v_shareaux) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + SCIP_BENDERS *__pyx_v_scip_benders; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + char const *__pyx_t_6; + SCIP_Bool __pyx_t_7; + SCIP_Bool __pyx_t_8; + SCIP_Bool __pyx_t_9; + SCIP_Bool __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + char const *__pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeBenders", 1); + + /* "src/pyscipopt/scip.pxi":4156 + * shareaux -- should the Benders' decomposition share the auxiliary variables of the highest priority Benders' decomposition + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBenders(self._scip, n, d, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4157 + * """ + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeBenders(self._scip, n, d, + * priority, cutlp, cutrelax, cutpseudo, shareaux, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_desc}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_d = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4158 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBenders(self._scip, n, d, # <<<<<<<<<<<<<< + * priority, cutlp, cutrelax, cutpseudo, shareaux, + * PyBendersCopy, PyBendersFree, PyBendersInit, PyBendersExit, PyBendersInitpre, + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 4158, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4158, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4159 + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBenders(self._scip, n, d, + * priority, cutlp, cutrelax, cutpseudo, shareaux, # <<<<<<<<<<<<<< + * PyBendersCopy, PyBendersFree, PyBendersInit, PyBendersExit, PyBendersInitpre, + * PyBendersExitpre, PyBendersInitsol, PyBendersExitsol, PyBendersGetvar, + */ + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4159, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_cutlp); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4159, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_cutrelax); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4159, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_cutpseudo); if (unlikely((__pyx_t_9 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4159, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_shareaux); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4159, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4158 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBenders(self._scip, n, d, # <<<<<<<<<<<<<< + * priority, cutlp, cutrelax, cutpseudo, shareaux, + * PyBendersCopy, PyBendersFree, PyBendersInit, PyBendersExit, PyBendersInitpre, + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeBenders(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6, __pyx_t_4, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_f_9pyscipopt_4scip_PyBendersCopy, __pyx_f_9pyscipopt_4scip_PyBendersFree, __pyx_f_9pyscipopt_4scip_PyBendersInit, __pyx_f_9pyscipopt_4scip_PyBendersExit, __pyx_f_9pyscipopt_4scip_PyBendersInitpre, __pyx_f_9pyscipopt_4scip_PyBendersExitpre, __pyx_f_9pyscipopt_4scip_PyBendersInitsol, __pyx_f_9pyscipopt_4scip_PyBendersExitsol, __pyx_f_9pyscipopt_4scip_PyBendersGetvar, __pyx_f_9pyscipopt_4scip_PyBendersCreatesub, __pyx_f_9pyscipopt_4scip_PyBendersPresubsolve, __pyx_f_9pyscipopt_4scip_PyBendersSolvesubconvex, __pyx_f_9pyscipopt_4scip_PyBendersSolvesub, __pyx_f_9pyscipopt_4scip_PyBendersPostsolve, __pyx_f_9pyscipopt_4scip_PyBendersFreesub, ((SCIP_BENDERSDATA *)__pyx_v_benders))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_11 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_11)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4166 + * benders)) + * cdef SCIP_BENDERS* scip_benders + * scip_benders = SCIPfindBenders(self._scip, n) # <<<<<<<<<<<<<< + * benders.model = weakref.proxy(self) + * benders.name = name + */ + __pyx_t_12 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_12) && PyErr_Occurred())) __PYX_ERR(0, 4166, __pyx_L1_error) + __pyx_v_scip_benders = SCIPfindBenders(__pyx_v_self->_scip, __pyx_t_12); + + /* "src/pyscipopt/scip.pxi":4167 + * cdef SCIP_BENDERS* scip_benders + * scip_benders = SCIPfindBenders(self._scip, n) + * benders.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * benders.name = name + * benders._benders = scip_benders + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_weakref); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_proxy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, ((PyObject *)__pyx_v_self)}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_1; + __Pyx_INCREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF((PyObject *)__pyx_v_benders->model); + __Pyx_DECREF((PyObject *)__pyx_v_benders->model); + __pyx_v_benders->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4168 + * scip_benders = SCIPfindBenders(self._scip, n) + * benders.model = weakref.proxy(self) + * benders.name = name # <<<<<<<<<<<<<< + * benders._benders = scip_benders + * Py_INCREF(benders) + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(0, 4168, __pyx_L1_error) + __pyx_t_3 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_benders->name); + __Pyx_DECREF(__pyx_v_benders->name); + __pyx_v_benders->name = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4169 + * benders.model = weakref.proxy(self) + * benders.name = name + * benders._benders = scip_benders # <<<<<<<<<<<<<< + * Py_INCREF(benders) + * + */ + __pyx_v_benders->_benders = __pyx_v_scip_benders; + + /* "src/pyscipopt/scip.pxi":4170 + * benders.name = name + * benders._benders = scip_benders + * Py_INCREF(benders) # <<<<<<<<<<<<<< + * + * def includeBenderscut(self, Benders benders, Benderscut benderscut, name, desc, priority=1, islpcut=True): + */ + Py_INCREF(((PyObject *)__pyx_v_benders)); + + /* "src/pyscipopt/scip.pxi":4142 + * Py_INCREF(nodesel) + * + * def includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True, # <<<<<<<<<<<<<< + * shareaux=False): + * """Include a Benders' decomposition. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeBenders", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4172 + * Py_INCREF(benders) + * + * def includeBenderscut(self, Benders benders, Benderscut benderscut, name, desc, priority=1, islpcut=True): # <<<<<<<<<<<<<< + * """ Include a Benders' decomposition cutting method + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_445includeBenderscut(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_444includeBenderscut, "Model.includeBenderscut(self, Benders benders, Benderscut benderscut, name, desc, priority=1, islpcut=True)\n Include a Benders' decomposition cutting method\n\n Keyword arguments:\n benders -- the Benders' decomposition that this cutting method is attached to\n benderscut --- the Benders' decomposition cutting method\n name -- the name\n desc -- the description\n priority -- priority of the Benders' decomposition\n islpcut -- is this cutting method suitable for generating cuts for convex relaxations?\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_445includeBenderscut = {"includeBenderscut", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_445includeBenderscut, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_444includeBenderscut}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_445includeBenderscut(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders = 0; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_benderscut = 0; + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_desc = 0; + PyObject *__pyx_v_priority = 0; + PyObject *__pyx_v_islpcut = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[6] = {0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("includeBenderscut (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_benders,&__pyx_n_s_benderscut,&__pyx_n_s_name,&__pyx_n_s_desc,&__pyx_n_s_priority,&__pyx_n_s_islpcut,0}; + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_1)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benders)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4172, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_benderscut)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4172, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBenderscut", 0, 4, 6, 1); __PYX_ERR(0, 4172, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4172, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBenderscut", 0, 4, 6, 2); __PYX_ERR(0, 4172, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (likely((values[3] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_desc)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[3]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4172, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("includeBenderscut", 0, 4, 6, 3); __PYX_ERR(0, 4172, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4172, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_islpcut); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4172, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "includeBenderscut") < 0)) __PYX_ERR(0, 4172, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)values[0]); + __pyx_v_benderscut = ((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)values[1]); + __pyx_v_name = values[2]; + __pyx_v_desc = values[3]; + __pyx_v_priority = values[4]; + __pyx_v_islpcut = values[5]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("includeBenderscut", 0, 4, 6, __pyx_nargs); __PYX_ERR(0, 4172, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.includeBenderscut", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benders), __pyx_ptype_9pyscipopt_4scip_Benders, 1, "benders", 0))) __PYX_ERR(0, 4172, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_benderscut), __pyx_ptype_9pyscipopt_4scip_Benderscut, 1, "benderscut", 0))) __PYX_ERR(0, 4172, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_444includeBenderscut(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_benders, __pyx_v_benderscut, __pyx_v_name, __pyx_v_desc, __pyx_v_priority, __pyx_v_islpcut); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_444includeBenderscut(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Benders *__pyx_v_benders, struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v_benderscut, PyObject *__pyx_v_name, PyObject *__pyx_v_desc, PyObject *__pyx_v_priority, PyObject *__pyx_v_islpcut) { + SCIP_BENDERS *__pyx_v__benders; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_d = NULL; + CYTHON_UNUSED SCIP_BENDERSCUT *__pyx_v_scip_benderscut; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_BENDERS *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + char const *__pyx_t_7; + SCIP_Bool __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + char const *__pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("includeBenderscut", 1); + + /* "src/pyscipopt/scip.pxi":4185 + * cdef SCIP_BENDERS* _benders + * + * _benders = benders._benders # <<<<<<<<<<<<<< + * + * n = str_conversion(name) + */ + __pyx_t_1 = __pyx_v_benders->_benders; + __pyx_v__benders = __pyx_t_1; + + /* "src/pyscipopt/scip.pxi":4187 + * _benders = benders._benders + * + * n = str_conversion(name) # <<<<<<<<<<<<<< + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBenderscut(self._scip, _benders, n, d, priority, islpcut, + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4188 + * + * n = str_conversion(name) + * d = str_conversion(desc) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPincludeBenderscut(self._scip, _benders, n, d, priority, islpcut, + * PyBenderscutCopy, PyBenderscutFree, PyBenderscutInit, PyBenderscutExit, + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_desc}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_d = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4189 + * n = str_conversion(name) + * d = str_conversion(desc) + * PY_SCIP_CALL(SCIPincludeBenderscut(self._scip, _benders, n, d, priority, islpcut, # <<<<<<<<<<<<<< + * PyBenderscutCopy, PyBenderscutFree, PyBenderscutInit, PyBenderscutExit, + * PyBenderscutInitsol, PyBenderscutExitsol, PyBenderscutExec, + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4189, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_d); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 4189, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4189, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_islpcut); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4189, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4192 + * PyBenderscutCopy, PyBenderscutFree, PyBenderscutInit, PyBenderscutExit, + * PyBenderscutInitsol, PyBenderscutExitsol, PyBenderscutExec, + * benderscut)) # <<<<<<<<<<<<<< + * + * cdef SCIP_BENDERSCUT* scip_benderscut + */ + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPincludeBenderscut(__pyx_v_self->_scip, __pyx_v__benders, __pyx_t_6, __pyx_t_7, __pyx_t_5, __pyx_t_8, __pyx_f_9pyscipopt_4scip_PyBenderscutCopy, __pyx_f_9pyscipopt_4scip_PyBenderscutFree, __pyx_f_9pyscipopt_4scip_PyBenderscutInit, __pyx_f_9pyscipopt_4scip_PyBenderscutExit, __pyx_f_9pyscipopt_4scip_PyBenderscutInitsol, __pyx_f_9pyscipopt_4scip_PyBenderscutExitsol, __pyx_f_9pyscipopt_4scip_PyBenderscutExec, ((SCIP_BENDERSCUTDATA *)__pyx_v_benderscut))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_9)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4195 + * + * cdef SCIP_BENDERSCUT* scip_benderscut + * scip_benderscut = SCIPfindBenderscut(_benders, n) # <<<<<<<<<<<<<< + * benderscut.model = weakref.proxy(self) + * benderscut.benders = benders + */ + __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 4195, __pyx_L1_error) + __pyx_v_scip_benderscut = SCIPfindBenderscut(__pyx_v__benders, __pyx_t_10); + + /* "src/pyscipopt/scip.pxi":4196 + * cdef SCIP_BENDERSCUT* scip_benderscut + * scip_benderscut = SCIPfindBenderscut(_benders, n) + * benderscut.model = weakref.proxy(self) # <<<<<<<<<<<<<< + * benderscut.benders = benders + * benderscut.name = name + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_weakref); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_proxy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_4 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF((PyObject *)__pyx_v_benderscut->model); + __Pyx_DECREF((PyObject *)__pyx_v_benderscut->model); + __pyx_v_benderscut->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4197 + * scip_benderscut = SCIPfindBenderscut(_benders, n) + * benderscut.model = weakref.proxy(self) + * benderscut.benders = benders # <<<<<<<<<<<<<< + * benderscut.name = name + * # TODO: It might be necessary in increment the reference to benders i.e Py_INCREF(benders) + */ + __Pyx_INCREF((PyObject *)__pyx_v_benders); + __Pyx_GIVEREF((PyObject *)__pyx_v_benders); + __Pyx_GOTREF((PyObject *)__pyx_v_benderscut->benders); + __Pyx_DECREF((PyObject *)__pyx_v_benderscut->benders); + __pyx_v_benderscut->benders = __pyx_v_benders; + + /* "src/pyscipopt/scip.pxi":4198 + * benderscut.model = weakref.proxy(self) + * benderscut.benders = benders + * benderscut.name = name # <<<<<<<<<<<<<< + * # TODO: It might be necessary in increment the reference to benders i.e Py_INCREF(benders) + * Py_INCREF(benderscut) + */ + if (!(likely(PyUnicode_CheckExact(__pyx_v_name))||((__pyx_v_name) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_v_name))) __PYX_ERR(0, 4198, __pyx_L1_error) + __pyx_t_4 = __pyx_v_name; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_benderscut->name); + __Pyx_DECREF(__pyx_v_benderscut->name); + __pyx_v_benderscut->name = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4200 + * benderscut.name = name + * # TODO: It might be necessary in increment the reference to benders i.e Py_INCREF(benders) + * Py_INCREF(benderscut) # <<<<<<<<<<<<<< + * + * + */ + Py_INCREF(((PyObject *)__pyx_v_benderscut)); + + /* "src/pyscipopt/scip.pxi":4172 + * Py_INCREF(benders) + * + * def includeBenderscut(self, Benders benders, Benderscut benderscut, name, desc, priority=1, islpcut=True): # <<<<<<<<<<<<<< + * """ Include a Benders' decomposition cutting method + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("pyscipopt.scip.Model.includeBenderscut", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4203 + * + * + * def getLPBranchCands(self): # <<<<<<<<<<<<<< + * """gets branching candidates for LP solution branching (fractional variables) along with solution values, + * fractionalities, and number of branching candidates; The number of branching candidates does NOT account + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_447getLPBranchCands(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_446getLPBranchCands, "Model.getLPBranchCands(self)\ngets branching candidates for LP solution branching (fractional variables) along with solution values,\n fractionalities, and number of branching candidates; The number of branching candidates does NOT account\n for fractional implicit integer variables which should not be used for branching decisions. Fractional\n implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1\n branching rules should always select the branching candidate among the first npriolpcands of the candidate list\n\n :return tuple (lpcands, lpcandssol, lpcadsfrac, nlpcands, npriolpcands, nfracimplvars) where\n\n lpcands: list of variables of LP branching candidates\n lpcandssol: list of LP candidate solution values\n lpcandsfrac\tlist of LP candidate fractionalities\n nlpcands: number of LP branching candidates\n npriolpcands: number of candidates with maximal priority\n nfracimplvars: number of fractional implicit integer variables\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_447getLPBranchCands = {"getLPBranchCands", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_447getLPBranchCands, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_446getLPBranchCands}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_447getLPBranchCands(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getLPBranchCands (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getLPBranchCands", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getLPBranchCands", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_446getLPBranchCands(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_446getLPBranchCands(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + int __pyx_v_nlpcands; + int __pyx_v_npriolpcands; + int __pyx_v_nfracimplvars; + SCIP_VAR **__pyx_v_lpcands; + SCIP_Real *__pyx_v_lpcandssol; + SCIP_Real *__pyx_v_lpcandsfrac; + int __pyx_9genexpr41__pyx_v_i; + int __pyx_9genexpr42__pyx_v_i; + int __pyx_9genexpr43__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getLPBranchCands", 1); + + /* "src/pyscipopt/scip.pxi":4229 + * cdef SCIP_Real* lpcandsfrac + * + * PY_SCIP_CALL(SCIPgetLPBranchCands(self._scip, &lpcands, &lpcandssol, &lpcandsfrac, # <<<<<<<<<<<<<< + * &nlpcands, &npriolpcands, &nfracimplvars)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/scip.pxi":4230 + * + * PY_SCIP_CALL(SCIPgetLPBranchCands(self._scip, &lpcands, &lpcandssol, &lpcandsfrac, + * &nlpcands, &npriolpcands, &nfracimplvars)) # <<<<<<<<<<<<<< + * + * return ([Variable.create(lpcands[i]) for i in range(nlpcands)], [lpcandssol[i] for i in range(nlpcands)], + */ + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetLPBranchCands(__pyx_v_self->_scip, (&__pyx_v_lpcands), (&__pyx_v_lpcandssol), (&__pyx_v_lpcandsfrac), (&__pyx_v_nlpcands), (&__pyx_v_npriolpcands), (&__pyx_v_nfracimplvars))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4232 + * &nlpcands, &npriolpcands, &nfracimplvars)) + * + * return ([Variable.create(lpcands[i]) for i in range(nlpcands)], [lpcandssol[i] for i in range(nlpcands)], # <<<<<<<<<<<<<< + * [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars) + * + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_v_nlpcands; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr41__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_lpcands[__pyx_9genexpr41__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __pyx_v_nlpcands; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr42__pyx_v_i = __pyx_t_7; + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_lpcandssol[__pyx_9genexpr42__pyx_v_i])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + } /* exit inner scope */ + { /* enter inner scope */ + + /* "src/pyscipopt/scip.pxi":4233 + * + * return ([Variable.create(lpcands[i]) for i in range(nlpcands)], [lpcandssol[i] for i in range(nlpcands)], + * [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars) # <<<<<<<<<<<<<< + * + * def getPseudoBranchCands(self): + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __pyx_v_nlpcands; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr43__pyx_v_i = __pyx_t_7; + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_lpcandsfrac[__pyx_9genexpr43__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + } /* exit inner scope */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_nlpcands); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_npriolpcands); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_nfracimplvars); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "src/pyscipopt/scip.pxi":4232 + * &nlpcands, &npriolpcands, &nfracimplvars)) + * + * return ([Variable.create(lpcands[i]) for i in range(nlpcands)], [lpcandssol[i] for i in range(nlpcands)], # <<<<<<<<<<<<<< + * [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars) + * + */ + __pyx_t_10 = PyTuple_New(6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1)) __PYX_ERR(0, 4232, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_2)) __PYX_ERR(0, 4232, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_t_3)) __PYX_ERR(0, 4232, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 3, __pyx_t_4)) __PYX_ERR(0, 4232, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 4, __pyx_t_8)) __PYX_ERR(0, 4232, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 5, __pyx_t_9)) __PYX_ERR(0, 4232, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_r = __pyx_t_10; + __pyx_t_10 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4203 + * + * + * def getLPBranchCands(self): # <<<<<<<<<<<<<< + * """gets branching candidates for LP solution branching (fractional variables) along with solution values, + * fractionalities, and number of branching candidates; The number of branching candidates does NOT account + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pyscipopt.scip.Model.getLPBranchCands", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4235 + * [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars) + * + * def getPseudoBranchCands(self): # <<<<<<<<<<<<<< + * """gets branching candidates for pseudo solution branching (non-fixed variables) + * along with the number of candidates. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_449getPseudoBranchCands(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_448getPseudoBranchCands, "Model.getPseudoBranchCands(self)\ngets branching candidates for pseudo solution branching (non-fixed variables)\n along with the number of candidates.\n\n :return tuple (pseudocands, npseudocands, npriopseudocands) where\n\n pseudocands: list of variables of pseudo branching candidates\n npseudocands: number of pseudo branching candidates\n npriopseudocands: number of candidates with maximal priority\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_449getPseudoBranchCands = {"getPseudoBranchCands", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_449getPseudoBranchCands, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_448getPseudoBranchCands}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_449getPseudoBranchCands(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPseudoBranchCands (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getPseudoBranchCands", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPseudoBranchCands", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_448getPseudoBranchCands(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_448getPseudoBranchCands(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + int __pyx_v_npseudocands; + int __pyx_v_npriopseudocands; + SCIP_VAR **__pyx_v_pseudocands; + int __pyx_9genexpr44__pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getPseudoBranchCands", 1); + + /* "src/pyscipopt/scip.pxi":4251 + * cdef SCIP_VAR** pseudocands + * + * PY_SCIP_CALL(SCIPgetPseudoBranchCands(self._scip, &pseudocands, &npseudocands, &npriopseudocands)) # <<<<<<<<<<<<<< + * + * return ([Variable.create(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetPseudoBranchCands(__pyx_v_self->_scip, (&__pyx_v_pseudocands), (&__pyx_v_npseudocands), (&__pyx_v_npriopseudocands))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4253 + * PY_SCIP_CALL(SCIPgetPseudoBranchCands(self._scip, &pseudocands, &npseudocands, &npriopseudocands)) + * + * return ([Variable.create(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands) # <<<<<<<<<<<<<< + * + * def branchVar(self, Variable variable): + */ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __pyx_v_npseudocands; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_9genexpr44__pyx_v_i = __pyx_t_7; + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Variable_create((__pyx_v_pseudocands[__pyx_9genexpr44__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 4253, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + } /* exit inner scope */ + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_npseudocands); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_npriopseudocands); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 4253, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(0, 4253, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3)) __PYX_ERR(0, 4253, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4235 + * [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars) + * + * def getPseudoBranchCands(self): # <<<<<<<<<<<<<< + * """gets branching candidates for pseudo solution branching (non-fixed variables) + * along with the number of candidates. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getPseudoBranchCands", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4255 + * return ([Variable.create(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands) + * + * def branchVar(self, Variable variable): # <<<<<<<<<<<<<< + * """Branch on a non-continuous variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_451branchVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_450branchVar, "Model.branchVar(self, Variable variable)\nBranch on a non-continuous variable.\n\n :param variable: Variable to branch on\n :return: tuple(downchild, eqchild, upchild) of Nodes of the left, middle and right child. Middle child only exists\n if branch variable is integer (it is None otherwise)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_451branchVar = {"branchVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_451branchVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_450branchVar}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_451branchVar(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchVar (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_variable,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_variable)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4255, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "branchVar") < 0)) __PYX_ERR(0, 4255, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_variable = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("branchVar", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4255, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.branchVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_variable), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "variable", 0))) __PYX_ERR(0, 4255, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_450branchVar(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_variable); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_450branchVar(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable) { + SCIP_NODE *__pyx_v_downchild; + SCIP_NODE *__pyx_v_eqchild; + SCIP_NODE *__pyx_v_upchild; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("branchVar", 1); + + /* "src/pyscipopt/scip.pxi":4267 + * cdef SCIP_NODE* upchild + * + * PY_SCIP_CALL(SCIPbranchVar(self._scip, (variable).scip_var, &downchild, &eqchild, &upchild)) # <<<<<<<<<<<<<< + * return Node.create(downchild), Node.create(eqchild), Node.create(upchild) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPbranchVar(__pyx_v_self->_scip, __pyx_v_variable->scip_var, (&__pyx_v_downchild), (&__pyx_v_eqchild), (&__pyx_v_upchild))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4268 + * + * PY_SCIP_CALL(SCIPbranchVar(self._scip, (variable).scip_var, &downchild, &eqchild, &upchild)) + * return Node.create(downchild), Node.create(eqchild), Node.create(upchild) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_downchild); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_eqchild); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_upchild); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 4268, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(0, 4268, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3)) __PYX_ERR(0, 4268, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4255 + * return ([Variable.create(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands) + * + * def branchVar(self, Variable variable): # <<<<<<<<<<<<<< + * """Branch on a non-continuous variable. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.branchVar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4271 + * + * + * def branchVarVal(self, variable, value): # <<<<<<<<<<<<<< + * """Branches on variable using a value which separates the domain of the variable. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_453branchVarVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_452branchVarVal, "Model.branchVarVal(self, variable, value)\nBranches on variable using a value which separates the domain of the variable.\n\n :param variable: Variable to branch on\n :param value: float, value to branch on\n :return: tuple(downchild, eqchild, upchild) of Nodes of the left, middle and right child. Middle child only exists\n if branch variable is integer (it is None otherwise)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_453branchVarVal = {"branchVarVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_453branchVarVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_452branchVarVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_453branchVarVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_variable = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("branchVarVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_variable,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_variable)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4271, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4271, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("branchVarVal", 1, 2, 2, 1); __PYX_ERR(0, 4271, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "branchVarVal") < 0)) __PYX_ERR(0, 4271, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_variable = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("branchVarVal", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4271, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.branchVarVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_452branchVarVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_variable, __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_452branchVarVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_variable, PyObject *__pyx_v_value) { + SCIP_NODE *__pyx_v_downchild; + SCIP_NODE *__pyx_v_eqchild; + SCIP_NODE *__pyx_v_upchild; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("branchVarVal", 1); + + /* "src/pyscipopt/scip.pxi":4284 + * cdef SCIP_NODE* upchild + * + * PY_SCIP_CALL(SCIPbranchVarVal(self._scip, (variable).scip_var, value, &downchild, &eqchild, &upchild)) # <<<<<<<<<<<<<< + * + * return Node.create(downchild), Node.create(eqchild), Node.create(upchild) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4284, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPbranchVarVal(__pyx_v_self->_scip, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_v_variable)->scip_var, __pyx_t_3, (&__pyx_v_downchild), (&__pyx_v_eqchild), (&__pyx_v_upchild))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4286 + * PY_SCIP_CALL(SCIPbranchVarVal(self._scip, (variable).scip_var, value, &downchild, &eqchild, &upchild)) + * + * return Node.create(downchild), Node.create(eqchild), Node.create(upchild) # <<<<<<<<<<<<<< + * + * def calcNodeselPriority(self, Variable variable, branchdir, targetvalue): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_downchild); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_eqchild); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_upchild); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1)) __PYX_ERR(0, 4286, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2)) __PYX_ERR(0, 4286, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4)) __PYX_ERR(0, 4286, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4271 + * + * + * def branchVarVal(self, variable, value): # <<<<<<<<<<<<<< + * """Branches on variable using a value which separates the domain of the variable. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.branchVarVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4288 + * return Node.create(downchild), Node.create(eqchild), Node.create(upchild) + * + * def calcNodeselPriority(self, Variable variable, branchdir, targetvalue): # <<<<<<<<<<<<<< + * """calculates the node selection priority for moving the given variable's LP value + * to the given target value; + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_455calcNodeselPriority(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_454calcNodeselPriority, "Model.calcNodeselPriority(self, Variable variable, branchdir, targetvalue)\ncalculates the node selection priority for moving the given variable's LP value\n to the given target value;\n this node selection priority can be given to the SCIPcreateChild() call\n\n :param variable: variable on which the branching is applied\n :param branchdir: type of branching that was performed\n :param targetvalue: new value of the variable in the child node\n :return: node selection priority for moving the given variable's LP value to the given target value\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_455calcNodeselPriority = {"calcNodeselPriority", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_455calcNodeselPriority, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_454calcNodeselPriority}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_455calcNodeselPriority(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable = 0; + PyObject *__pyx_v_branchdir = 0; + PyObject *__pyx_v_targetvalue = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("calcNodeselPriority (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_variable,&__pyx_n_s_branchdir,&__pyx_n_s_targetvalue,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_variable)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4288, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_branchdir)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4288, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("calcNodeselPriority", 1, 3, 3, 1); __PYX_ERR(0, 4288, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_targetvalue)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4288, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("calcNodeselPriority", 1, 3, 3, 2); __PYX_ERR(0, 4288, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "calcNodeselPriority") < 0)) __PYX_ERR(0, 4288, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_variable = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_branchdir = values[1]; + __pyx_v_targetvalue = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("calcNodeselPriority", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 4288, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.calcNodeselPriority", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_variable), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "variable", 0))) __PYX_ERR(0, 4288, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_454calcNodeselPriority(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_variable, __pyx_v_branchdir, __pyx_v_targetvalue); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_454calcNodeselPriority(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable, PyObject *__pyx_v_branchdir, PyObject *__pyx_v_targetvalue) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_BRANCHDIR __pyx_t_1; + SCIP_Real __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("calcNodeselPriority", 1); + + /* "src/pyscipopt/scip.pxi":4299 + * + * """ + * return SCIPcalcNodeselPriority(self._scip, variable.scip_var, branchdir, targetvalue) # <<<<<<<<<<<<<< + * + * def calcChildEstimate(self, Variable variable, targetvalue): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_As_SCIP_BRANCHDIR(__pyx_v_branchdir); if (unlikely((__pyx_t_1 == ((SCIP_BRANCHDIR)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4299, __pyx_L1_error) + __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_targetvalue); if (unlikely((__pyx_t_2 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4299, __pyx_L1_error) + __pyx_t_3 = PyFloat_FromDouble(SCIPcalcNodeselPriority(__pyx_v_self->_scip, __pyx_v_variable->scip_var, __pyx_t_1, __pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4288 + * return Node.create(downchild), Node.create(eqchild), Node.create(upchild) + * + * def calcNodeselPriority(self, Variable variable, branchdir, targetvalue): # <<<<<<<<<<<<<< + * """calculates the node selection priority for moving the given variable's LP value + * to the given target value; + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.calcNodeselPriority", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4301 + * return SCIPcalcNodeselPriority(self._scip, variable.scip_var, branchdir, targetvalue) + * + * def calcChildEstimate(self, Variable variable, targetvalue): # <<<<<<<<<<<<<< + * """Calculates an estimate for the objective of the best feasible solution + * contained in the subtree after applying the given branching; + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_457calcChildEstimate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_456calcChildEstimate, "Model.calcChildEstimate(self, Variable variable, targetvalue)\nCalculates an estimate for the objective of the best feasible solution\n contained in the subtree after applying the given branching;\n this estimate can be given to the SCIPcreateChild() call\n\n :param variable: Variable to compute the estimate for\n :param targetvalue: new value of the variable in the child node\n :return: objective estimate of the best solution in the subtree after applying the given branching\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_457calcChildEstimate = {"calcChildEstimate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_457calcChildEstimate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_456calcChildEstimate}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_457calcChildEstimate(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable = 0; + PyObject *__pyx_v_targetvalue = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("calcChildEstimate (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_variable,&__pyx_n_s_targetvalue,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_variable)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4301, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_targetvalue)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4301, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("calcChildEstimate", 1, 2, 2, 1); __PYX_ERR(0, 4301, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "calcChildEstimate") < 0)) __PYX_ERR(0, 4301, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_variable = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_targetvalue = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("calcChildEstimate", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4301, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.calcChildEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_variable), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "variable", 0))) __PYX_ERR(0, 4301, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_456calcChildEstimate(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_variable, __pyx_v_targetvalue); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_456calcChildEstimate(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_variable, PyObject *__pyx_v_targetvalue) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Real __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("calcChildEstimate", 1); + + /* "src/pyscipopt/scip.pxi":4311 + * + * """ + * return SCIPcalcChildEstimate(self._scip, variable.scip_var, targetvalue) # <<<<<<<<<<<<<< + * + * def createChild(self, nodeselprio, estimate): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_targetvalue); if (unlikely((__pyx_t_1 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4311, __pyx_L1_error) + __pyx_t_2 = PyFloat_FromDouble(SCIPcalcChildEstimate(__pyx_v_self->_scip, __pyx_v_variable->scip_var, __pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4301 + * return SCIPcalcNodeselPriority(self._scip, variable.scip_var, branchdir, targetvalue) + * + * def calcChildEstimate(self, Variable variable, targetvalue): # <<<<<<<<<<<<<< + * """Calculates an estimate for the objective of the best feasible solution + * contained in the subtree after applying the given branching; + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.calcChildEstimate", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4313 + * return SCIPcalcChildEstimate(self._scip, variable.scip_var, targetvalue) + * + * def createChild(self, nodeselprio, estimate): # <<<<<<<<<<<<<< + * """Create a child node of the focus node. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_459createChild(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_458createChild, "Model.createChild(self, nodeselprio, estimate)\nCreate a child node of the focus node.\n\n :param nodeselprio: float, node selection priority of new node\n :param estimate: float, estimate for(transformed) objective value of best feasible solution in subtree\n :return: Node, the child which was created\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_459createChild = {"createChild", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_459createChild, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_458createChild}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_459createChild(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_nodeselprio = 0; + PyObject *__pyx_v_estimate = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createChild (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nodeselprio,&__pyx_n_s_estimate,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nodeselprio)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4313, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_estimate)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4313, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("createChild", 1, 2, 2, 1); __PYX_ERR(0, 4313, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createChild") < 0)) __PYX_ERR(0, 4313, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_nodeselprio = values[0]; + __pyx_v_estimate = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createChild", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4313, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createChild", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_458createChild(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_nodeselprio, __pyx_v_estimate); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_458createChild(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_nodeselprio, PyObject *__pyx_v_estimate) { + SCIP_NODE *__pyx_v_child; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createChild", 1); + + /* "src/pyscipopt/scip.pxi":4322 + * """ + * cdef SCIP_NODE* child + * PY_SCIP_CALL(SCIPcreateChild(self._scip, &child, nodeselprio, estimate)) # <<<<<<<<<<<<<< + * return Node.create(child) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_nodeselprio); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4322, __pyx_L1_error) + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_estimate); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4322, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateChild(__pyx_v_self->_scip, (&__pyx_v_child), __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4323 + * cdef SCIP_NODE* child + * PY_SCIP_CALL(SCIPcreateChild(self._scip, &child, nodeselprio, estimate)) + * return Node.create(child) # <<<<<<<<<<<<<< + * + * # Diving methods (Diving is LP related) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_4Node_create(__pyx_v_child); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4313 + * return SCIPcalcChildEstimate(self._scip, variable.scip_var, targetvalue) + * + * def createChild(self, nodeselprio, estimate): # <<<<<<<<<<<<<< + * """Create a child node of the focus node. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.createChild", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4326 + * + * # Diving methods (Diving is LP related) + * def startDive(self): # <<<<<<<<<<<<<< + * """Initiates LP diving + * It allows the user to change the LP in several ways, solve, change again, etc, without affecting the actual LP that has. When endDive() is called, + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_461startDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_460startDive, "Model.startDive(self)\nInitiates LP diving\n It allows the user to change the LP in several ways, solve, change again, etc, without affecting the actual LP that has. When endDive() is called,\n SCIP will undo all changes done and recover the LP it had before startDive\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_461startDive = {"startDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_461startDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_460startDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_461startDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("startDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("startDive", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "startDive", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_460startDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_460startDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("startDive", 1); + + /* "src/pyscipopt/scip.pxi":4331 + * SCIP will undo all changes done and recover the LP it had before startDive + * """ + * PY_SCIP_CALL(SCIPstartDive(self._scip)) # <<<<<<<<<<<<<< + * + * def endDive(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPstartDive(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4326 + * + * # Diving methods (Diving is LP related) + * def startDive(self): # <<<<<<<<<<<<<< + * """Initiates LP diving + * It allows the user to change the LP in several ways, solve, change again, etc, without affecting the actual LP that has. When endDive() is called, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.startDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4333 + * PY_SCIP_CALL(SCIPstartDive(self._scip)) + * + * def endDive(self): # <<<<<<<<<<<<<< + * """Quits probing and resets bounds and constraints to the focus node's environment""" + * PY_SCIP_CALL(SCIPendDive(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_463endDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_462endDive, "Model.endDive(self)\nQuits probing and resets bounds and constraints to the focus node's environment"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_463endDive = {"endDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_463endDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_462endDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_463endDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("endDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("endDive", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "endDive", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_462endDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_462endDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("endDive", 1); + + /* "src/pyscipopt/scip.pxi":4335 + * def endDive(self): + * """Quits probing and resets bounds and constraints to the focus node's environment""" + * PY_SCIP_CALL(SCIPendDive(self._scip)) # <<<<<<<<<<<<<< + * + * def chgVarObjDive(self, Variable var, newobj): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPendDive(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4335, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4333 + * PY_SCIP_CALL(SCIPstartDive(self._scip)) + * + * def endDive(self): # <<<<<<<<<<<<<< + * """Quits probing and resets bounds and constraints to the focus node's environment""" + * PY_SCIP_CALL(SCIPendDive(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.endDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4337 + * PY_SCIP_CALL(SCIPendDive(self._scip)) + * + * def chgVarObjDive(self, Variable var, newobj): # <<<<<<<<<<<<<< + * """changes (column) variable's objective value in current dive""" + * PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_465chgVarObjDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_464chgVarObjDive, "Model.chgVarObjDive(self, Variable var, newobj)\nchanges (column) variable's objective value in current dive"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_465chgVarObjDive = {"chgVarObjDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_465chgVarObjDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_464chgVarObjDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_465chgVarObjDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_newobj = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarObjDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_newobj,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4337, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newobj)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4337, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarObjDive", 1, 2, 2, 1); __PYX_ERR(0, 4337, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarObjDive") < 0)) __PYX_ERR(0, 4337, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_newobj = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarObjDive", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4337, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarObjDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4337, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_464chgVarObjDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_newobj); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_464chgVarObjDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_newobj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarObjDive", 1); + + /* "src/pyscipopt/scip.pxi":4339 + * def chgVarObjDive(self, Variable var, newobj): + * """changes (column) variable's objective value in current dive""" + * PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj)) # <<<<<<<<<<<<<< + * + * def chgVarLbDive(self, Variable var, newbound): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_newobj); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4339, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarObjDive(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4337 + * PY_SCIP_CALL(SCIPendDive(self._scip)) + * + * def chgVarObjDive(self, Variable var, newobj): # <<<<<<<<<<<<<< + * """changes (column) variable's objective value in current dive""" + * PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarObjDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4341 + * PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj)) + * + * def chgVarLbDive(self, Variable var, newbound): # <<<<<<<<<<<<<< + * """changes variable's current lb in current dive""" + * PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_467chgVarLbDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_466chgVarLbDive, "Model.chgVarLbDive(self, Variable var, newbound)\nchanges variable's current lb in current dive"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_467chgVarLbDive = {"chgVarLbDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_467chgVarLbDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_466chgVarLbDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_467chgVarLbDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_newbound = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarLbDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_newbound,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4341, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newbound)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4341, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarLbDive", 1, 2, 2, 1); __PYX_ERR(0, 4341, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarLbDive") < 0)) __PYX_ERR(0, 4341, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_newbound = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarLbDive", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4341, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLbDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4341, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_466chgVarLbDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_newbound); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_466chgVarLbDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_newbound) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarLbDive", 1); + + /* "src/pyscipopt/scip.pxi":4343 + * def chgVarLbDive(self, Variable var, newbound): + * """changes variable's current lb in current dive""" + * PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound)) # <<<<<<<<<<<<<< + * + * def chgVarUbDive(self, Variable var, newbound): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_newbound); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4343, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarLbDive(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4341 + * PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj)) + * + * def chgVarLbDive(self, Variable var, newbound): # <<<<<<<<<<<<<< + * """changes variable's current lb in current dive""" + * PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLbDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4345 + * PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound)) + * + * def chgVarUbDive(self, Variable var, newbound): # <<<<<<<<<<<<<< + * """changes variable's current ub in current dive""" + * PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_469chgVarUbDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_468chgVarUbDive, "Model.chgVarUbDive(self, Variable var, newbound)\nchanges variable's current ub in current dive"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_469chgVarUbDive = {"chgVarUbDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_469chgVarUbDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_468chgVarUbDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_469chgVarUbDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_newbound = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarUbDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_newbound,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4345, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newbound)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4345, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarUbDive", 1, 2, 2, 1); __PYX_ERR(0, 4345, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarUbDive") < 0)) __PYX_ERR(0, 4345, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_newbound = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarUbDive", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4345, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUbDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4345, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_468chgVarUbDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_newbound); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_468chgVarUbDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_newbound) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarUbDive", 1); + + /* "src/pyscipopt/scip.pxi":4347 + * def chgVarUbDive(self, Variable var, newbound): + * """changes variable's current ub in current dive""" + * PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound)) # <<<<<<<<<<<<<< + * + * def getVarLbDive(self, Variable var): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_newbound); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4347, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarUbDive(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4345 + * PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound)) + * + * def chgVarUbDive(self, Variable var, newbound): # <<<<<<<<<<<<<< + * """changes variable's current ub in current dive""" + * PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUbDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4349 + * PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound)) + * + * def getVarLbDive(self, Variable var): # <<<<<<<<<<<<<< + * """returns variable's current lb in current dive""" + * return SCIPgetVarLbDive(self._scip, var.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_471getVarLbDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_470getVarLbDive, "Model.getVarLbDive(self, Variable var)\nreturns variable's current lb in current dive"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_471getVarLbDive = {"getVarLbDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_471getVarLbDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_470getVarLbDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_471getVarLbDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVarLbDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4349, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getVarLbDive") < 0)) __PYX_ERR(0, 4349, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getVarLbDive", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4349, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getVarLbDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4349, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_470getVarLbDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_470getVarLbDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVarLbDive", 1); + + /* "src/pyscipopt/scip.pxi":4351 + * def getVarLbDive(self, Variable var): + * """returns variable's current lb in current dive""" + * return SCIPgetVarLbDive(self._scip, var.scip_var) # <<<<<<<<<<<<<< + * + * def getVarUbDive(self, Variable var): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetVarLbDive(__pyx_v_self->_scip, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4349 + * PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound)) + * + * def getVarLbDive(self, Variable var): # <<<<<<<<<<<<<< + * """returns variable's current lb in current dive""" + * return SCIPgetVarLbDive(self._scip, var.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getVarLbDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4353 + * return SCIPgetVarLbDive(self._scip, var.scip_var) + * + * def getVarUbDive(self, Variable var): # <<<<<<<<<<<<<< + * """returns variable's current ub in current dive""" + * return SCIPgetVarUbDive(self._scip, var.scip_var) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_473getVarUbDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_472getVarUbDive, "Model.getVarUbDive(self, Variable var)\nreturns variable's current ub in current dive"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_473getVarUbDive = {"getVarUbDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_473getVarUbDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_472getVarUbDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_473getVarUbDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVarUbDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4353, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getVarUbDive") < 0)) __PYX_ERR(0, 4353, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getVarUbDive", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4353, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getVarUbDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4353, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_472getVarUbDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_472getVarUbDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVarUbDive", 1); + + /* "src/pyscipopt/scip.pxi":4355 + * def getVarUbDive(self, Variable var): + * """returns variable's current ub in current dive""" + * return SCIPgetVarUbDive(self._scip, var.scip_var) # <<<<<<<<<<<<<< + * + * def chgRowLhsDive(self, Row row, newlhs): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetVarUbDive(__pyx_v_self->_scip, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4353 + * return SCIPgetVarLbDive(self._scip, var.scip_var) + * + * def getVarUbDive(self, Variable var): # <<<<<<<<<<<<<< + * """returns variable's current ub in current dive""" + * return SCIPgetVarUbDive(self._scip, var.scip_var) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getVarUbDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4357 + * return SCIPgetVarUbDive(self._scip, var.scip_var) + * + * def chgRowLhsDive(self, Row row, newlhs): # <<<<<<<<<<<<<< + * """changes row lhs in current dive, change will be undone after diving + * ends, for permanent changes use SCIPchgRowLhs() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_475chgRowLhsDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_474chgRowLhsDive, "Model.chgRowLhsDive(self, Row row, newlhs)\nchanges row lhs in current dive, change will be undone after diving\n ends, for permanent changes use SCIPchgRowLhs()\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_475chgRowLhsDive = {"chgRowLhsDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_475chgRowLhsDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_474chgRowLhsDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_475chgRowLhsDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + PyObject *__pyx_v_newlhs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgRowLhsDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_newlhs,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4357, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newlhs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4357, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgRowLhsDive", 1, 2, 2, 1); __PYX_ERR(0, 4357, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgRowLhsDive") < 0)) __PYX_ERR(0, 4357, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_newlhs = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgRowLhsDive", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4357, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgRowLhsDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 4357, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_474chgRowLhsDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row, __pyx_v_newlhs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_474chgRowLhsDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, PyObject *__pyx_v_newlhs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgRowLhsDive", 1); + + /* "src/pyscipopt/scip.pxi":4361 + * ends, for permanent changes use SCIPchgRowLhs() + * """ + * PY_SCIP_CALL(SCIPchgRowLhsDive(self._scip, row.scip_row, newlhs)) # <<<<<<<<<<<<<< + * + * def chgRowRhsDive(self, Row row, newrhs): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_newlhs); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4361, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgRowLhsDive(__pyx_v_self->_scip, __pyx_v_row->scip_row, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4357 + * return SCIPgetVarUbDive(self._scip, var.scip_var) + * + * def chgRowLhsDive(self, Row row, newlhs): # <<<<<<<<<<<<<< + * """changes row lhs in current dive, change will be undone after diving + * ends, for permanent changes use SCIPchgRowLhs() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgRowLhsDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4363 + * PY_SCIP_CALL(SCIPchgRowLhsDive(self._scip, row.scip_row, newlhs)) + * + * def chgRowRhsDive(self, Row row, newrhs): # <<<<<<<<<<<<<< + * """changes row rhs in current dive, change will be undone after diving + * ends, for permanent changes use SCIPchgRowLhs() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_477chgRowRhsDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_476chgRowRhsDive, "Model.chgRowRhsDive(self, Row row, newrhs)\nchanges row rhs in current dive, change will be undone after diving\n ends, for permanent changes use SCIPchgRowLhs()\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_477chgRowRhsDive = {"chgRowRhsDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_477chgRowRhsDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_476chgRowRhsDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_477chgRowRhsDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + PyObject *__pyx_v_newrhs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgRowRhsDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_newrhs,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4363, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newrhs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4363, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgRowRhsDive", 1, 2, 2, 1); __PYX_ERR(0, 4363, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgRowRhsDive") < 0)) __PYX_ERR(0, 4363, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_newrhs = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgRowRhsDive", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4363, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgRowRhsDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 4363, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_476chgRowRhsDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row, __pyx_v_newrhs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_476chgRowRhsDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, PyObject *__pyx_v_newrhs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgRowRhsDive", 1); + + /* "src/pyscipopt/scip.pxi":4367 + * ends, for permanent changes use SCIPchgRowLhs() + * """ + * PY_SCIP_CALL(SCIPchgRowRhsDive(self._scip, row.scip_row, newrhs)) # <<<<<<<<<<<<<< + * + * def addRowDive(self, Row row): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_newrhs); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4367, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgRowRhsDive(__pyx_v_self->_scip, __pyx_v_row->scip_row, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4367, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4363 + * PY_SCIP_CALL(SCIPchgRowLhsDive(self._scip, row.scip_row, newlhs)) + * + * def chgRowRhsDive(self, Row row, newrhs): # <<<<<<<<<<<<<< + * """changes row rhs in current dive, change will be undone after diving + * ends, for permanent changes use SCIPchgRowLhs() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgRowRhsDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4369 + * PY_SCIP_CALL(SCIPchgRowRhsDive(self._scip, row.scip_row, newrhs)) + * + * def addRowDive(self, Row row): # <<<<<<<<<<<<<< + * """adds a row to the LP in current dive""" + * PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_479addRowDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_478addRowDive, "Model.addRowDive(self, Row row)\nadds a row to the LP in current dive"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_479addRowDive = {"addRowDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_479addRowDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_478addRowDive}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_479addRowDive(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addRowDive (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4369, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addRowDive") < 0)) __PYX_ERR(0, 4369, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addRowDive", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4369, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addRowDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 4369, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_478addRowDive(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_478addRowDive(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addRowDive", 1); + + /* "src/pyscipopt/scip.pxi":4371 + * def addRowDive(self, Row row): + * """adds a row to the LP in current dive""" + * PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row)) # <<<<<<<<<<<<<< + * + * def solveDiveLP(self, itlim = -1): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddRowDive(__pyx_v_self->_scip, __pyx_v_row->scip_row)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4369 + * PY_SCIP_CALL(SCIPchgRowRhsDive(self._scip, row.scip_row, newrhs)) + * + * def addRowDive(self, Row row): # <<<<<<<<<<<<<< + * """adds a row to the LP in current dive""" + * PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.addRowDive", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4373 + * PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row)) + * + * def solveDiveLP(self, itlim = -1): # <<<<<<<<<<<<<< + * """solves the LP of the current dive no separation or pricing is applied + * no separation or pricing is applied + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_481solveDiveLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_480solveDiveLP, "Model.solveDiveLP(self, itlim=-1)\nsolves the LP of the current dive no separation or pricing is applied\n no separation or pricing is applied\n :param itlim: maximal number of LP iterations to perform (Default value = -1, that is, no limit)\n returns two booleans:\n lperror -- if an unresolved lp error occured\n cutoff -- whether the LP was infeasible or the objective limit was reached\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_481solveDiveLP = {"solveDiveLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_481solveDiveLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_480solveDiveLP}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_481solveDiveLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_itlim = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solveDiveLP (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_itlim,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_neg_1)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itlim); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4373, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "solveDiveLP") < 0)) __PYX_ERR(0, 4373, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_itlim = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("solveDiveLP", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 4373, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.solveDiveLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_480solveDiveLP(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_itlim); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_480solveDiveLP(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_itlim) { + SCIP_Bool __pyx_v_lperror; + SCIP_Bool __pyx_v_cutoff; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solveDiveLP", 1); + + /* "src/pyscipopt/scip.pxi":4384 + * cdef SCIP_Bool cutoff + * + * PY_SCIP_CALL(SCIPsolveDiveLP(self._scip, itlim, &lperror, &cutoff)) # <<<<<<<<<<<<<< + * return lperror, cutoff + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_itlim); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4384, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsolveDiveLP(__pyx_v_self->_scip, __pyx_t_3, (&__pyx_v_lperror), (&__pyx_v_cutoff))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_3 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_3 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4384, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4385 + * + * PY_SCIP_CALL(SCIPsolveDiveLP(self._scip, itlim, &lperror, &cutoff)) + * return lperror, cutoff # <<<<<<<<<<<<<< + * + * def inRepropagation(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_lperror); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_cutoff); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 4385, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(0, 4385, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4373 + * PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row)) + * + * def solveDiveLP(self, itlim = -1): # <<<<<<<<<<<<<< + * """solves the LP of the current dive no separation or pricing is applied + * no separation or pricing is applied + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.solveDiveLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4387 + * return lperror, cutoff + * + * def inRepropagation(self): # <<<<<<<<<<<<<< + * """returns if the current node is already solved and only propagated again.""" + * return SCIPinRepropagation(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_483inRepropagation(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_482inRepropagation, "Model.inRepropagation(self)\nreturns if the current node is already solved and only propagated again."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_483inRepropagation = {"inRepropagation", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_483inRepropagation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_482inRepropagation}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_483inRepropagation(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("inRepropagation (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("inRepropagation", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "inRepropagation", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_482inRepropagation(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_482inRepropagation(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("inRepropagation", 1); + + /* "src/pyscipopt/scip.pxi":4389 + * def inRepropagation(self): + * """returns if the current node is already solved and only propagated again.""" + * return SCIPinRepropagation(self._scip) # <<<<<<<<<<<<<< + * + * # Probing methods (Probing is tree based) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPinRepropagation(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4389, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4387 + * return lperror, cutoff + * + * def inRepropagation(self): # <<<<<<<<<<<<<< + * """returns if the current node is already solved and only propagated again.""" + * return SCIPinRepropagation(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.inRepropagation", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4392 + * + * # Probing methods (Probing is tree based) + * def startProbing(self): # <<<<<<<<<<<<<< + * """Initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), + * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), SCIPsolveProbingLP(), etc available + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_485startProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_484startProbing, "Model.startProbing(self)\nInitiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),\n SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), SCIPsolveProbingLP(), etc available\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_485startProbing = {"startProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_485startProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_484startProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_485startProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("startProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("startProbing", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "startProbing", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_484startProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_484startProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("startProbing", 1); + + /* "src/pyscipopt/scip.pxi":4396 + * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), SCIPsolveProbingLP(), etc available + * """ + * PY_SCIP_CALL( SCIPstartProbing(self._scip) ) # <<<<<<<<<<<<<< + * + * def endProbing(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPstartProbing(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4392 + * + * # Probing methods (Probing is tree based) + * def startProbing(self): # <<<<<<<<<<<<<< + * """Initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), + * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), SCIPsolveProbingLP(), etc available + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.startProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4398 + * PY_SCIP_CALL( SCIPstartProbing(self._scip) ) + * + * def endProbing(self): # <<<<<<<<<<<<<< + * """Quits probing and resets bounds and constraints to the focus node's environment""" + * PY_SCIP_CALL( SCIPendProbing(self._scip) ) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_487endProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_486endProbing, "Model.endProbing(self)\nQuits probing and resets bounds and constraints to the focus node's environment"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_487endProbing = {"endProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_487endProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_486endProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_487endProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("endProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("endProbing", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "endProbing", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_486endProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_486endProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("endProbing", 1); + + /* "src/pyscipopt/scip.pxi":4400 + * def endProbing(self): + * """Quits probing and resets bounds and constraints to the focus node's environment""" + * PY_SCIP_CALL( SCIPendProbing(self._scip) ) # <<<<<<<<<<<<<< + * + * def newProbingNode(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPendProbing(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4400, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4398 + * PY_SCIP_CALL( SCIPstartProbing(self._scip) ) + * + * def endProbing(self): # <<<<<<<<<<<<<< + * """Quits probing and resets bounds and constraints to the focus node's environment""" + * PY_SCIP_CALL( SCIPendProbing(self._scip) ) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.endProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4402 + * PY_SCIP_CALL( SCIPendProbing(self._scip) ) + * + * def newProbingNode(self): # <<<<<<<<<<<<<< + * """creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the + * probing path with a call to backtrackProbing() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_489newProbingNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_488newProbingNode, "Model.newProbingNode(self)\ncreates a new probing sub node, whose changes can be undone by backtracking to a higher node in the\n probing path with a call to backtrackProbing()\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_489newProbingNode = {"newProbingNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_489newProbingNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_488newProbingNode}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_489newProbingNode(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("newProbingNode (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("newProbingNode", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "newProbingNode", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_488newProbingNode(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_488newProbingNode(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("newProbingNode", 1); + + /* "src/pyscipopt/scip.pxi":4406 + * probing path with a call to backtrackProbing() + * """ + * PY_SCIP_CALL( SCIPnewProbingNode(self._scip) ) # <<<<<<<<<<<<<< + * + * def backtrackProbing(self, probingdepth): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPnewProbingNode(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4402 + * PY_SCIP_CALL( SCIPendProbing(self._scip) ) + * + * def newProbingNode(self): # <<<<<<<<<<<<<< + * """creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the + * probing path with a call to backtrackProbing() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.newProbingNode", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4408 + * PY_SCIP_CALL( SCIPnewProbingNode(self._scip) ) + * + * def backtrackProbing(self, probingdepth): # <<<<<<<<<<<<<< + * """undoes all changes to the problem applied in probing up to the given probing depth + * :param probingdepth: probing depth of the node in the probing path that should be reactivated + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_491backtrackProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_490backtrackProbing, "Model.backtrackProbing(self, probingdepth)\nundoes all changes to the problem applied in probing up to the given probing depth\n :param probingdepth: probing depth of the node in the probing path that should be reactivated\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_491backtrackProbing = {"backtrackProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_491backtrackProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_490backtrackProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_491backtrackProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_probingdepth = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("backtrackProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_probingdepth,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_probingdepth)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4408, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "backtrackProbing") < 0)) __PYX_ERR(0, 4408, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_probingdepth = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("backtrackProbing", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4408, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.backtrackProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_490backtrackProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_probingdepth); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_490backtrackProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_probingdepth) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("backtrackProbing", 1); + + /* "src/pyscipopt/scip.pxi":4412 + * :param probingdepth: probing depth of the node in the probing path that should be reactivated + * """ + * PY_SCIP_CALL( SCIPbacktrackProbing(self._scip, probingdepth) ) # <<<<<<<<<<<<<< + * + * def getProbingDepth(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_probingdepth); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4412, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPbacktrackProbing(__pyx_v_self->_scip, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_3 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_3 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4408 + * PY_SCIP_CALL( SCIPnewProbingNode(self._scip) ) + * + * def backtrackProbing(self, probingdepth): # <<<<<<<<<<<<<< + * """undoes all changes to the problem applied in probing up to the given probing depth + * :param probingdepth: probing depth of the node in the probing path that should be reactivated + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.backtrackProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4414 + * PY_SCIP_CALL( SCIPbacktrackProbing(self._scip, probingdepth) ) + * + * def getProbingDepth(self): # <<<<<<<<<<<<<< + * """returns the current probing depth""" + * return SCIPgetProbingDepth(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_493getProbingDepth(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_492getProbingDepth, "Model.getProbingDepth(self)\nreturns the current probing depth"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_493getProbingDepth = {"getProbingDepth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_493getProbingDepth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_492getProbingDepth}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_493getProbingDepth(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getProbingDepth (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getProbingDepth", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getProbingDepth", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_492getProbingDepth(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_492getProbingDepth(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getProbingDepth", 1); + + /* "src/pyscipopt/scip.pxi":4416 + * def getProbingDepth(self): + * """returns the current probing depth""" + * return SCIPgetProbingDepth(self._scip) # <<<<<<<<<<<<<< + * + * def chgVarObjProbing(self, Variable var, newobj): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPgetProbingDepth(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4414 + * PY_SCIP_CALL( SCIPbacktrackProbing(self._scip, probingdepth) ) + * + * def getProbingDepth(self): # <<<<<<<<<<<<<< + * """returns the current probing depth""" + * return SCIPgetProbingDepth(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getProbingDepth", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4418 + * return SCIPgetProbingDepth(self._scip) + * + * def chgVarObjProbing(self, Variable var, newobj): # <<<<<<<<<<<<<< + * """changes (column) variable's objective value during probing mode""" + * PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) ) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_495chgVarObjProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_494chgVarObjProbing, "Model.chgVarObjProbing(self, Variable var, newobj)\nchanges (column) variable's objective value during probing mode"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_495chgVarObjProbing = {"chgVarObjProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_495chgVarObjProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_494chgVarObjProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_495chgVarObjProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_newobj = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarObjProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_newobj,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4418, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_newobj)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4418, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarObjProbing", 1, 2, 2, 1); __PYX_ERR(0, 4418, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarObjProbing") < 0)) __PYX_ERR(0, 4418, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_newobj = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarObjProbing", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4418, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarObjProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4418, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_494chgVarObjProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_newobj); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_494chgVarObjProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_newobj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarObjProbing", 1); + + /* "src/pyscipopt/scip.pxi":4420 + * def chgVarObjProbing(self, Variable var, newobj): + * """changes (column) variable's objective value during probing mode""" + * PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) ) # <<<<<<<<<<<<<< + * + * def chgVarLbProbing(self, Variable var, lb): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_newobj); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4420, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarObjProbing(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4418 + * return SCIPgetProbingDepth(self._scip) + * + * def chgVarObjProbing(self, Variable var, newobj): # <<<<<<<<<<<<<< + * """changes (column) variable's objective value during probing mode""" + * PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) ) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarObjProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4422 + * PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) ) + * + * def chgVarLbProbing(self, Variable var, lb): # <<<<<<<<<<<<<< + * """changes the variable lower bound during probing mode + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_497chgVarLbProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_496chgVarLbProbing, "Model.chgVarLbProbing(self, Variable var, lb)\nchanges the variable lower bound during probing mode\n\n :param Variable var: variable to change bound of\n :param lb: new lower bound (set to None for -infinity)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_497chgVarLbProbing = {"chgVarLbProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_497chgVarLbProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_496chgVarLbProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_497chgVarLbProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_lb = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarLbProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_lb,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4422, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_lb)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4422, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarLbProbing", 1, 2, 2, 1); __PYX_ERR(0, 4422, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarLbProbing") < 0)) __PYX_ERR(0, 4422, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_lb = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarLbProbing", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4422, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLbProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4422, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_496chgVarLbProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_lb); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_496chgVarLbProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_lb) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarLbProbing", 0); + __Pyx_INCREF(__pyx_v_lb); + + /* "src/pyscipopt/scip.pxi":4428 + * :param lb: new lower bound (set to None for -infinity) + * """ + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb)) + */ + __pyx_t_1 = (__pyx_v_lb == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4429 + * """ + * if lb is None: + * lb = -SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb)) + * + */ + __pyx_t_2 = PyFloat_FromDouble((-SCIPinfinity(__pyx_v_self->_scip))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_lb, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4428 + * :param lb: new lower bound (set to None for -infinity) + * """ + * if lb is None: # <<<<<<<<<<<<<< + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb)) + */ + } + + /* "src/pyscipopt/scip.pxi":4430 + * if lb is None: + * lb = -SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb)) # <<<<<<<<<<<<<< + * + * def chgVarUbProbing(self, Variable var, ub): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_lb); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4430, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarLbProbing(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4422 + * PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) ) + * + * def chgVarLbProbing(self, Variable var, lb): # <<<<<<<<<<<<<< + * """changes the variable lower bound during probing mode + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarLbProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_lb); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4432 + * PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb)) + * + * def chgVarUbProbing(self, Variable var, ub): # <<<<<<<<<<<<<< + * """changes the variable upper bound during probing mode + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_499chgVarUbProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_498chgVarUbProbing, "Model.chgVarUbProbing(self, Variable var, ub)\nchanges the variable upper bound during probing mode\n\n :param Variable var: variable to change bound of\n :param ub: new upper bound (set to None for +infinity)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_499chgVarUbProbing = {"chgVarUbProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_499chgVarUbProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_498chgVarUbProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_499chgVarUbProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_ub = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarUbProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_ub,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4432, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ub)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4432, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarUbProbing", 1, 2, 2, 1); __PYX_ERR(0, 4432, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarUbProbing") < 0)) __PYX_ERR(0, 4432, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_ub = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarUbProbing", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4432, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUbProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4432, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_498chgVarUbProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_ub); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_498chgVarUbProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_ub) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarUbProbing", 0); + __Pyx_INCREF(__pyx_v_ub); + + /* "src/pyscipopt/scip.pxi":4438 + * :param ub: new upper bound (set to None for +infinity) + * """ + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub)) + */ + __pyx_t_1 = (__pyx_v_ub == Py_None); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4439 + * """ + * if ub is None: + * ub = SCIPinfinity(self._scip) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub)) + * + */ + __pyx_t_2 = PyFloat_FromDouble(SCIPinfinity(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF_SET(__pyx_v_ub, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4438 + * :param ub: new upper bound (set to None for +infinity) + * """ + * if ub is None: # <<<<<<<<<<<<<< + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub)) + */ + } + + /* "src/pyscipopt/scip.pxi":4440 + * if ub is None: + * ub = SCIPinfinity(self._scip) + * PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub)) # <<<<<<<<<<<<<< + * + * def fixVarProbing(self, Variable var, fixedval): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_ub); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4440, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarUbProbing(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4432 + * PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb)) + * + * def chgVarUbProbing(self, Variable var, ub): # <<<<<<<<<<<<<< + * """changes the variable upper bound during probing mode + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarUbProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ub); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4442 + * PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub)) + * + * def fixVarProbing(self, Variable var, fixedval): # <<<<<<<<<<<<<< + * """Fixes a variable at the current probing node.""" + * PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) ) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_501fixVarProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_500fixVarProbing, "Model.fixVarProbing(self, Variable var, fixedval)\nFixes a variable at the current probing node."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_501fixVarProbing = {"fixVarProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_501fixVarProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_500fixVarProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_501fixVarProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_fixedval = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("fixVarProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_fixedval,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4442, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fixedval)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4442, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("fixVarProbing", 1, 2, 2, 1); __PYX_ERR(0, 4442, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "fixVarProbing") < 0)) __PYX_ERR(0, 4442, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_fixedval = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("fixVarProbing", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4442, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.fixVarProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4442, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_500fixVarProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_fixedval); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_500fixVarProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_fixedval) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_Real __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("fixVarProbing", 1); + + /* "src/pyscipopt/scip.pxi":4444 + * def fixVarProbing(self, Variable var, fixedval): + * """Fixes a variable at the current probing node.""" + * PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) ) # <<<<<<<<<<<<<< + * + * def isObjChangedProbing(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_fixedval); if (unlikely((__pyx_t_3 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4444, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPfixVarProbing(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4442 + * PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub)) + * + * def fixVarProbing(self, Variable var, fixedval): # <<<<<<<<<<<<<< + * """Fixes a variable at the current probing node.""" + * PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) ) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.fixVarProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4446 + * PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) ) + * + * def isObjChangedProbing(self): # <<<<<<<<<<<<<< + * """returns whether the objective function has changed during probing mode""" + * return SCIPisObjChangedProbing(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_503isObjChangedProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_502isObjChangedProbing, "Model.isObjChangedProbing(self)\nreturns whether the objective function has changed during probing mode"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_503isObjChangedProbing = {"isObjChangedProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_503isObjChangedProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_502isObjChangedProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_503isObjChangedProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("isObjChangedProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("isObjChangedProbing", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "isObjChangedProbing", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_502isObjChangedProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_502isObjChangedProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("isObjChangedProbing", 1); + + /* "src/pyscipopt/scip.pxi":4448 + * def isObjChangedProbing(self): + * """returns whether the objective function has changed during probing mode""" + * return SCIPisObjChangedProbing(self._scip) # <<<<<<<<<<<<<< + * + * def inProbing(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPisObjChangedProbing(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4448, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4446 + * PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) ) + * + * def isObjChangedProbing(self): # <<<<<<<<<<<<<< + * """returns whether the objective function has changed during probing mode""" + * return SCIPisObjChangedProbing(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.isObjChangedProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4450 + * return SCIPisObjChangedProbing(self._scip) + * + * def inProbing(self): # <<<<<<<<<<<<<< + * """returns whether we are in probing mode; probing mode is activated via startProbing() and stopped via endProbing()""" + * return SCIPinProbing(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_505inProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_504inProbing, "Model.inProbing(self)\nreturns whether we are in probing mode; probing mode is activated via startProbing() and stopped via endProbing()"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_505inProbing = {"inProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_505inProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_504inProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_505inProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("inProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("inProbing", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "inProbing", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_504inProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_504inProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("inProbing", 1); + + /* "src/pyscipopt/scip.pxi":4452 + * def inProbing(self): + * """returns whether we are in probing mode; probing mode is activated via startProbing() and stopped via endProbing()""" + * return SCIPinProbing(self._scip) # <<<<<<<<<<<<<< + * + * def solveProbingLP(self, itlim = -1): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPinProbing(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4450 + * return SCIPisObjChangedProbing(self._scip) + * + * def inProbing(self): # <<<<<<<<<<<<<< + * """returns whether we are in probing mode; probing mode is activated via startProbing() and stopped via endProbing()""" + * return SCIPinProbing(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.inProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4454 + * return SCIPinProbing(self._scip) + * + * def solveProbingLP(self, itlim = -1): # <<<<<<<<<<<<<< + * """solves the LP at the current probing node (cannot be applied at preprocessing stage) + * no separation or pricing is applied + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_507solveProbingLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_506solveProbingLP, "Model.solveProbingLP(self, itlim=-1)\nsolves the LP at the current probing node (cannot be applied at preprocessing stage)\n no separation or pricing is applied\n :param itlim: maximal number of LP iterations to perform (Default value = -1, that is, no limit)\n returns two booleans:\n lperror -- if an unresolved lp error occured\n cutoff -- whether the LP was infeasible or the objective limit was reached\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_507solveProbingLP = {"solveProbingLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_507solveProbingLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_506solveProbingLP}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_507solveProbingLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_itlim = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solveProbingLP (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_itlim,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_int_neg_1)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itlim); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4454, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "solveProbingLP") < 0)) __PYX_ERR(0, 4454, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_itlim = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("solveProbingLP", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 4454, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.solveProbingLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_506solveProbingLP(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_itlim); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_506solveProbingLP(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_itlim) { + SCIP_Bool __pyx_v_lperror; + SCIP_Bool __pyx_v_cutoff; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solveProbingLP", 1); + + /* "src/pyscipopt/scip.pxi":4465 + * cdef SCIP_Bool cutoff + * + * PY_SCIP_CALL( SCIPsolveProbingLP(self._scip, itlim, &lperror, &cutoff) ) # <<<<<<<<<<<<<< + * return lperror, cutoff + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_itlim); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4465, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsolveProbingLP(__pyx_v_self->_scip, __pyx_t_3, (&__pyx_v_lperror), (&__pyx_v_cutoff))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_3 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_3 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4465, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4466 + * + * PY_SCIP_CALL( SCIPsolveProbingLP(self._scip, itlim, &lperror, &cutoff) ) + * return lperror, cutoff # <<<<<<<<<<<<<< + * + * def applyCutsProbing(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_lperror); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_cutoff); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 4466, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(0, 4466, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4454 + * return SCIPinProbing(self._scip) + * + * def solveProbingLP(self, itlim = -1): # <<<<<<<<<<<<<< + * """solves the LP at the current probing node (cannot be applied at preprocessing stage) + * no separation or pricing is applied + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.solveProbingLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4468 + * return lperror, cutoff + * + * def applyCutsProbing(self): # <<<<<<<<<<<<<< + * """applies the cuts in the separation storage to the LP and clears the storage afterwards; + * this method can only be applied during probing; the user should resolve the probing LP afterwards + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_509applyCutsProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_508applyCutsProbing, "Model.applyCutsProbing(self)\napplies the cuts in the separation storage to the LP and clears the storage afterwards;\n this method can only be applied during probing; the user should resolve the probing LP afterwards\n in order to get a new solution\n returns:\n cutoff -- whether an empty domain was created\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_509applyCutsProbing = {"applyCutsProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_509applyCutsProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_508applyCutsProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_509applyCutsProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("applyCutsProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("applyCutsProbing", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "applyCutsProbing", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_508applyCutsProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_508applyCutsProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_Bool __pyx_v_cutoff; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("applyCutsProbing", 1); + + /* "src/pyscipopt/scip.pxi":4477 + * cdef SCIP_Bool cutoff + * + * PY_SCIP_CALL( SCIPapplyCutsProbing(self._scip, &cutoff) ) # <<<<<<<<<<<<<< + * return cutoff + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPapplyCutsProbing(__pyx_v_self->_scip, (&__pyx_v_cutoff))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4478 + * + * PY_SCIP_CALL( SCIPapplyCutsProbing(self._scip, &cutoff) ) + * return cutoff # <<<<<<<<<<<<<< + * + * def propagateProbing(self, maxproprounds): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_cutoff); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4468 + * return lperror, cutoff + * + * def applyCutsProbing(self): # <<<<<<<<<<<<<< + * """applies the cuts in the separation storage to the LP and clears the storage afterwards; + * this method can only be applied during probing; the user should resolve the probing LP afterwards + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.applyCutsProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4480 + * return cutoff + * + * def propagateProbing(self, maxproprounds): # <<<<<<<<<<<<<< + * """applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; + * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_511propagateProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_510propagateProbing, "Model.propagateProbing(self, maxproprounds)\napplies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;\n the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()\n and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed\n bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation\n :param maxproprounds: maximal number of propagation rounds (Default value = -1, that is, no limit)\n returns:\n cutoff -- whether the probing node can be cutoff\n ndomredsfound -- number of domain reductions found\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_511propagateProbing = {"propagateProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_511propagateProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_510propagateProbing}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_511propagateProbing(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_maxproprounds = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("propagateProbing (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_maxproprounds,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_maxproprounds)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4480, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "propagateProbing") < 0)) __PYX_ERR(0, 4480, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_maxproprounds = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("propagateProbing", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4480, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.propagateProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_510propagateProbing(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_maxproprounds); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_510propagateProbing(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_maxproprounds) { + SCIP_Bool __pyx_v_cutoff; + SCIP_Longint __pyx_v_ndomredsfound; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("propagateProbing", 1); + + /* "src/pyscipopt/scip.pxi":4493 + * cdef SCIP_Longint ndomredsfound + * + * PY_SCIP_CALL( SCIPpropagateProbing(self._scip, maxproprounds, &cutoff, &ndomredsfound) ) # <<<<<<<<<<<<<< + * return cutoff, ndomredsfound + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_maxproprounds); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4493, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPpropagateProbing(__pyx_v_self->_scip, __pyx_t_3, (&__pyx_v_cutoff), (&__pyx_v_ndomredsfound))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_3 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_3 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_3, 1+__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4494 + * + * PY_SCIP_CALL( SCIPpropagateProbing(self._scip, maxproprounds, &cutoff, &ndomredsfound) ) + * return cutoff, ndomredsfound # <<<<<<<<<<<<<< + * + * def interruptSolve(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_cutoff); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyInt_From_SCIP_Longint(__pyx_v_ndomredsfound); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1)) __PYX_ERR(0, 4494, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2)) __PYX_ERR(0, 4494, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4480 + * return cutoff + * + * def propagateProbing(self, maxproprounds): # <<<<<<<<<<<<<< + * """applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; + * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.propagateProbing", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4496 + * return cutoff, ndomredsfound + * + * def interruptSolve(self): # <<<<<<<<<<<<<< + * """Interrupt the solving process as soon as possible.""" + * PY_SCIP_CALL(SCIPinterruptSolve(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_513interruptSolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_512interruptSolve, "Model.interruptSolve(self)\nInterrupt the solving process as soon as possible."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_513interruptSolve = {"interruptSolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_513interruptSolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_512interruptSolve}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_513interruptSolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("interruptSolve (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("interruptSolve", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "interruptSolve", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_512interruptSolve(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_512interruptSolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("interruptSolve", 1); + + /* "src/pyscipopt/scip.pxi":4498 + * def interruptSolve(self): + * """Interrupt the solving process as soon as possible.""" + * PY_SCIP_CALL(SCIPinterruptSolve(self._scip)) # <<<<<<<<<<<<<< + * + * def restartSolve(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPinterruptSolve(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4496 + * return cutoff, ndomredsfound + * + * def interruptSolve(self): # <<<<<<<<<<<<<< + * """Interrupt the solving process as soon as possible.""" + * PY_SCIP_CALL(SCIPinterruptSolve(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.interruptSolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4500 + * PY_SCIP_CALL(SCIPinterruptSolve(self._scip)) + * + * def restartSolve(self): # <<<<<<<<<<<<<< + * """Restarts the solving process as soon as possible.""" + * PY_SCIP_CALL(SCIPrestartSolve(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_515restartSolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_514restartSolve, "Model.restartSolve(self)\nRestarts the solving process as soon as possible."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_515restartSolve = {"restartSolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_515restartSolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_514restartSolve}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_515restartSolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("restartSolve (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("restartSolve", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "restartSolve", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_514restartSolve(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_514restartSolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("restartSolve", 1); + + /* "src/pyscipopt/scip.pxi":4502 + * def restartSolve(self): + * """Restarts the solving process as soon as possible.""" + * PY_SCIP_CALL(SCIPrestartSolve(self._scip)) # <<<<<<<<<<<<<< + * + * # Solution functions + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPrestartSolve(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4500 + * PY_SCIP_CALL(SCIPinterruptSolve(self._scip)) + * + * def restartSolve(self): # <<<<<<<<<<<<<< + * """Restarts the solving process as soon as possible.""" + * PY_SCIP_CALL(SCIPrestartSolve(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.restartSolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4506 + * # Solution functions + * + * def writeLP(self, filename="LP.lp"): # <<<<<<<<<<<<<< + * """writes current LP to a file + * :param filename: file name (Default value = "LP.lp") + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_517writeLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_516writeLP, "Model.writeLP(self, filename=u'LP.lp')\nwrites current LP to a file\n :param filename: file name (Default value = \"LP.lp\")\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_517writeLP = {"writeLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_517writeLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_516writeLP}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_517writeLP(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeLP (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_LP_lp)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4506, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeLP") < 0)) __PYX_ERR(0, 4506, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeLP", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 4506, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_516writeLP(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_516writeLP(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_absfile = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char const *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeLP", 1); + + /* "src/pyscipopt/scip.pxi":4510 + * :param filename: file name (Default value = "LP.lp") + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4510, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4511 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * absfile = str_conversion(abspath(filename)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4513 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * absfile = str_conversion(abspath(filename)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL( SCIPwriteLP(self._scip, absfile) ) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_abspath); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4513, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_absfile = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4514 + * + * absfile = str_conversion(abspath(filename)) + * PY_SCIP_CALL( SCIPwriteLP(self._scip, absfile) ) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_absfile); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 4514, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPwriteLP(__pyx_v_self->_scip, __pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4516 + * PY_SCIP_CALL( SCIPwriteLP(self._scip, absfile) ) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def createSol(self, Heur heur = None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4506 + * # Solution functions + * + * def writeLP(self, filename="LP.lp"): # <<<<<<<<<<<<<< + * """writes current LP to a file + * :param filename: file name (Default value = "LP.lp") + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeLP", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_absfile); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4518 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def createSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a new primal solution in the transformed space. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_519createSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_518createSol, "Model.createSol(self, Heur heur=None)\nCreate a new primal solution in the transformed space.\n\n :param Heur heur: heuristic that found the solution (Default value = None)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_519createSol = {"createSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_519createSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_518createSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_519createSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_heur,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Heur *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_heur); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4518, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createSol") < 0)) __PYX_ERR(0, 4518, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_heur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createSol", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 4518, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_heur), __pyx_ptype_9pyscipopt_4scip_Heur, 1, "heur", 0))) __PYX_ERR(0, 4518, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_518createSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_heur); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_518createSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur) { + SCIP_HEUR *__pyx_v__heur; + SCIP_SOL *__pyx_v__sol; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_solution = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createSol", 1); + + /* "src/pyscipopt/scip.pxi":4527 + * cdef SCIP_SOL* _sol + * + * if isinstance(heur, Heur): # <<<<<<<<<<<<<< + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_heur), __pyx_ptype_9pyscipopt_4scip_Heur); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4528 + * + * if isinstance(heur, Heur): + * n = str_conversion(heur.name) # <<<<<<<<<<<<<< + * _heur = SCIPfindHeur(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_heur->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4529 + * if isinstance(heur, Heur): + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) # <<<<<<<<<<<<<< + * else: + * _heur = NULL + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4529, __pyx_L1_error) + __pyx_v__heur = SCIPfindHeur(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":4527 + * cdef SCIP_SOL* _sol + * + * if isinstance(heur, Heur): # <<<<<<<<<<<<<< + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":4531 + * _heur = SCIPfindHeur(self._scip, n) + * else: + * _heur = NULL # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreateSol(self._scip, &_sol, _heur)) + * solution = Solution.create(self._scip, _sol) + */ + /*else*/ { + __pyx_v__heur = NULL; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":4532 + * else: + * _heur = NULL + * PY_SCIP_CALL(SCIPcreateSol(self._scip, &_sol, _heur)) # <<<<<<<<<<<<<< + * solution = Solution.create(self._scip, _sol) + * return solution + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateSol(__pyx_v_self->_scip, (&__pyx_v__sol), __pyx_v__heur)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4533 + * _heur = NULL + * PY_SCIP_CALL(SCIPcreateSol(self._scip, &_sol, _heur)) + * solution = Solution.create(self._scip, _sol) # <<<<<<<<<<<<<< + * return solution + * + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, __pyx_v__sol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_solution = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4534 + * PY_SCIP_CALL(SCIPcreateSol(self._scip, &_sol, _heur)) + * solution = Solution.create(self._scip, _sol) + * return solution # <<<<<<<<<<<<<< + * + * def createPartialSol(self, Heur heur = None): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_solution); + __pyx_r = __pyx_v_solution; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4518 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def createSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a new primal solution in the transformed space. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.createSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4536 + * return solution + * + * def createPartialSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a partial primal solution, initialized to unknown values. + * :param Heur heur: heuristic that found the solution (Default value = None) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_521createPartialSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_520createPartialSol, "Model.createPartialSol(self, Heur heur=None)\nCreate a partial primal solution, initialized to unknown values.\n :param Heur heur: heuristic that found the solution (Default value = None)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_521createPartialSol = {"createPartialSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_521createPartialSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_520createPartialSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_521createPartialSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createPartialSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_heur,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Heur *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_heur); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4536, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createPartialSol") < 0)) __PYX_ERR(0, 4536, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_heur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createPartialSol", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 4536, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createPartialSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_heur), __pyx_ptype_9pyscipopt_4scip_Heur, 1, "heur", 0))) __PYX_ERR(0, 4536, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_520createPartialSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_heur); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_520createPartialSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur) { + SCIP_HEUR *__pyx_v__heur; + SCIP_SOL *__pyx_v__sol; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_partialsolution = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createPartialSol", 1); + + /* "src/pyscipopt/scip.pxi":4544 + * cdef SCIP_SOL* _sol + * + * if isinstance(heur, Heur): # <<<<<<<<<<<<<< + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_heur), __pyx_ptype_9pyscipopt_4scip_Heur); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4545 + * + * if isinstance(heur, Heur): + * n = str_conversion(heur.name) # <<<<<<<<<<<<<< + * _heur = SCIPfindHeur(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_heur->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4546 + * if isinstance(heur, Heur): + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) # <<<<<<<<<<<<<< + * else: + * _heur = NULL + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4546, __pyx_L1_error) + __pyx_v__heur = SCIPfindHeur(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":4544 + * cdef SCIP_SOL* _sol + * + * if isinstance(heur, Heur): # <<<<<<<<<<<<<< + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":4548 + * _heur = SCIPfindHeur(self._scip, n) + * else: + * _heur = NULL # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcreatePartialSol(self._scip, &_sol, _heur)) + * partialsolution = Solution.create(self._scip, _sol) + */ + /*else*/ { + __pyx_v__heur = NULL; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":4549 + * else: + * _heur = NULL + * PY_SCIP_CALL(SCIPcreatePartialSol(self._scip, &_sol, _heur)) # <<<<<<<<<<<<<< + * partialsolution = Solution.create(self._scip, _sol) + * return partialsolution + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreatePartialSol(__pyx_v_self->_scip, (&__pyx_v__sol), __pyx_v__heur)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4549, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4550 + * _heur = NULL + * PY_SCIP_CALL(SCIPcreatePartialSol(self._scip, &_sol, _heur)) + * partialsolution = Solution.create(self._scip, _sol) # <<<<<<<<<<<<<< + * return partialsolution + * + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, __pyx_v__sol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4550, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_partialsolution = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4551 + * PY_SCIP_CALL(SCIPcreatePartialSol(self._scip, &_sol, _heur)) + * partialsolution = Solution.create(self._scip, _sol) + * return partialsolution # <<<<<<<<<<<<<< + * + * def createOrigSol(self, Heur heur = None): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_partialsolution); + __pyx_r = __pyx_v_partialsolution; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4536 + * return solution + * + * def createPartialSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a partial primal solution, initialized to unknown values. + * :param Heur heur: heuristic that found the solution (Default value = None) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.createPartialSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_partialsolution); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4553 + * return partialsolution + * + * def createOrigSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a new primal solution in the original space. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_523createOrigSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_522createOrigSol, "Model.createOrigSol(self, Heur heur=None)\nCreate a new primal solution in the original space.\n\n :param Heur heur: heuristic that found the solution (Default value = None)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_523createOrigSol = {"createOrigSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_523createOrigSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_522createOrigSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_523createOrigSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("createOrigSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_heur,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Heur *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_heur); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4553, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "createOrigSol") < 0)) __PYX_ERR(0, 4553, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_heur = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("createOrigSol", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 4553, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.createOrigSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_heur), __pyx_ptype_9pyscipopt_4scip_Heur, 1, "heur", 0))) __PYX_ERR(0, 4553, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_522createOrigSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_heur); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_522createOrigSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v_heur) { + SCIP_HEUR *__pyx_v__heur; + SCIP_SOL *__pyx_v__sol; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_solution = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("createOrigSol", 1); + + /* "src/pyscipopt/scip.pxi":4562 + * cdef SCIP_SOL* _sol + * + * if isinstance(heur, Heur): # <<<<<<<<<<<<<< + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_heur), __pyx_ptype_9pyscipopt_4scip_Heur); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4563 + * + * if isinstance(heur, Heur): + * n = str_conversion(heur.name) # <<<<<<<<<<<<<< + * _heur = SCIPfindHeur(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4563, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_heur->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4563, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4564 + * if isinstance(heur, Heur): + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) # <<<<<<<<<<<<<< + * else: + * _heur = NULL + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4564, __pyx_L1_error) + __pyx_v__heur = SCIPfindHeur(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":4562 + * cdef SCIP_SOL* _sol + * + * if isinstance(heur, Heur): # <<<<<<<<<<<<<< + * n = str_conversion(heur.name) + * _heur = SCIPfindHeur(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":4566 + * _heur = SCIPfindHeur(self._scip, n) + * else: + * _heur = NULL # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPcreateOrigSol(self._scip, &_sol, _heur)) + */ + /*else*/ { + __pyx_v__heur = NULL; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":4568 + * _heur = NULL + * + * PY_SCIP_CALL(SCIPcreateOrigSol(self._scip, &_sol, _heur)) # <<<<<<<<<<<<<< + * solution = Solution.create(self._scip, _sol) + * return solution + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcreateOrigSol(__pyx_v_self->_scip, (&__pyx_v__sol), __pyx_v__heur)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4569 + * + * PY_SCIP_CALL(SCIPcreateOrigSol(self._scip, &_sol, _heur)) + * solution = Solution.create(self._scip, _sol) # <<<<<<<<<<<<<< + * return solution + * + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, __pyx_v__sol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_solution = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4570 + * PY_SCIP_CALL(SCIPcreateOrigSol(self._scip, &_sol, _heur)) + * solution = Solution.create(self._scip, _sol) + * return solution # <<<<<<<<<<<<<< + * + * def printBestSol(self, write_zeros=False): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_solution); + __pyx_r = __pyx_v_solution; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4553 + * return partialsolution + * + * def createOrigSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a new primal solution in the original space. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.createOrigSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_solution); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4572 + * return solution + * + * def printBestSol(self, write_zeros=False): # <<<<<<<<<<<<<< + * """Prints the best feasible primal solution.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_525printBestSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_524printBestSol, "Model.printBestSol(self, write_zeros=False)\nPrints the best feasible primal solution."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_525printBestSol = {"printBestSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_525printBestSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_524printBestSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_525printBestSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_write_zeros = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("printBestSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_write_zeros,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_write_zeros); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4572, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "printBestSol") < 0)) __PYX_ERR(0, 4572, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_write_zeros = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("printBestSol", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 4572, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.printBestSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_524printBestSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_write_zeros); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_524printBestSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_write_zeros) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + SCIP_Bool __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("printBestSol", 1); + + /* "src/pyscipopt/scip.pxi":4574 + * def printBestSol(self, write_zeros=False): + * """Prints the best feasible primal solution.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4575 + * """Prints the best feasible primal solution.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, NULL, write_zeros)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4577 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, NULL, write_zeros)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_write_zeros); if (unlikely((__pyx_t_6 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4577, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintBestSol(__pyx_v_self->_scip, NULL, __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4577, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4579 + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, NULL, write_zeros)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def printSol(self, Solution solution=None, write_zeros=False): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4572 + * return solution + * + * def printBestSol(self, write_zeros=False): # <<<<<<<<<<<<<< + * """Prints the best feasible primal solution.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.printBestSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4581 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def printSol(self, Solution solution=None, write_zeros=False): # <<<<<<<<<<<<<< + * """Print the given primal solution. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_527printSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_526printSol, "Model.printSol(self, Solution solution=None, write_zeros=False)\nPrint the given primal solution.\n\n Keyword arguments:\n solution -- solution to print\n write_zeros -- include variables that are set to zero\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_527printSol = {"printSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_527printSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_526printSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_527printSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_write_zeros = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("printSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_write_zeros,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL((PyObject *)((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4581, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_write_zeros); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4581, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "printSol") < 0)) __PYX_ERR(0, 4581, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_write_zeros = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("printSol", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 4581, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.printSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 4581, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_526printSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution, __pyx_v_write_zeros); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_526printSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_write_zeros) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + SCIP_Bool __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("printSol", 1); + + /* "src/pyscipopt/scip.pxi":4589 + * """ + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4589, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4590 + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * if solution is None: + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4592 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * if solution is None: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPprintSol(self._scip, NULL, NULL, write_zeros)) + * else: + */ + __pyx_t_6 = (((PyObject *)__pyx_v_solution) == Py_None); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":4593 + * + * if solution is None: + * PY_SCIP_CALL(SCIPprintSol(self._scip, NULL, NULL, write_zeros)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, NULL, write_zeros)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_write_zeros); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4593, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintSol(__pyx_v_self->_scip, NULL, NULL, __pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4592 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * if solution is None: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPprintSol(self._scip, NULL, NULL, write_zeros)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":4595 + * PY_SCIP_CALL(SCIPprintSol(self._scip, NULL, NULL, write_zeros)) + * else: + * PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, NULL, write_zeros)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_write_zeros); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4595, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintSol(__pyx_v_self->_scip, __pyx_v_solution->sol, NULL, __pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":4597 + * PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, NULL, write_zeros)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def writeBestSol(self, filename="origprob.sol", write_zeros=False): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4581 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def printSol(self, Solution solution=None, write_zeros=False): # <<<<<<<<<<<<<< + * """Print the given primal solution. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.printSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4599 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeBestSol(self, filename="origprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the best feasible primal solution to a file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_529writeBestSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_528writeBestSol, "Model.writeBestSol(self, filename=u'origprob.sol', write_zeros=False)\nWrite the best feasible primal solution to a file.\n\n Keyword arguments:\n filename -- name of the output file\n write_zeros -- include variables that are set to zero\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_529writeBestSol = {"writeBestSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_529writeBestSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_528writeBestSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_529writeBestSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_write_zeros = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeBestSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_write_zeros,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_origprob_sol)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4599, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_write_zeros); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4599, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeBestSol") < 0)) __PYX_ERR(0, 4599, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + __pyx_v_write_zeros = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeBestSol", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 4599, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeBestSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_528writeBestSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename, __pyx_v_write_zeros); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_528writeBestSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_write_zeros) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_f = NULL; + FILE *__pyx_v_cfile; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + SCIP_Bool __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeBestSol", 1); + + /* "src/pyscipopt/scip.pxi":4607 + * """ + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4607, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4608 + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * # use this doubled opening pattern to ensure that IOErrors are + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4612 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, cfile, write_zeros)) + */ + /*with:*/ { + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_filename)) __PYX_ERR(0, 4612, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_u_w); + __Pyx_GIVEREF(__pyx_n_u_w); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_n_u_w)) __PYX_ERR(0, 4612, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_enter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4612, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4612, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + __pyx_v_f = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4613 + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, cfile, write_zeros)) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4613, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4613, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4613, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cfile = fdopen(__pyx_t_5, ((char const *)"w")); + + /* "src/pyscipopt/scip.pxi":4614 + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, cfile, write_zeros)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4614, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_write_zeros); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4614, __pyx_L7_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintBestSol(__pyx_v_self->_scip, __pyx_v_cfile, __pyx_t_10)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4614, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4614, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4612 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, cfile, write_zeros)) + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + /*except:*/ { + __Pyx_AddTraceback("pyscipopt.scip.Model.writeBestSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 4612, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4612, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4612, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_12 < 0) __PYX_ERR(0, 4612, __pyx_L9_except_error) + __pyx_t_13 = (!__pyx_t_12); + if (unlikely(__pyx_t_13)) { + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_4); + __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 4612, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_6) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__107, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "src/pyscipopt/scip.pxi":4616 + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, cfile, write_zeros)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def writeBestTransSol(self, filename="transprob.sol", write_zeros=False): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4599 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeBestSol(self, filename="origprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the best feasible primal solution to a file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeBestSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_f); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4618 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeBestTransSol(self, filename="transprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the best feasible primal solution for the transformed problem to a file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_531writeBestTransSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_530writeBestTransSol, "Model.writeBestTransSol(self, filename=u'transprob.sol', write_zeros=False)\nWrite the best feasible primal solution for the transformed problem to a file.\n\n Keyword arguments:\n filename -- name of the output file\n write_zeros -- include variables that are set to zero\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_531writeBestTransSol = {"writeBestTransSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_531writeBestTransSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_530writeBestTransSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_531writeBestTransSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_write_zeros = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeBestTransSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_write_zeros,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_transprob_sol)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4618, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_write_zeros); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4618, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeBestTransSol") < 0)) __PYX_ERR(0, 4618, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + __pyx_v_write_zeros = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeBestTransSol", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 4618, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeBestTransSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_530writeBestTransSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename, __pyx_v_write_zeros); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_530writeBestTransSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_write_zeros) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_f = NULL; + FILE *__pyx_v_cfile; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + SCIP_Bool __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeBestTransSol", 1); + + /* "src/pyscipopt/scip.pxi":4625 + * write_zeros -- include variables that are set to zero + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4625, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4626 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * # use this double opening pattern to ensure that IOErrors are + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4630 + * # use this double opening pattern to ensure that IOErrors are + * # triggered early and in python not in C, Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintBestTransSol(self._scip, cfile, write_zeros)) + */ + /*with:*/ { + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_filename)) __PYX_ERR(0, 4630, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_u_w); + __Pyx_GIVEREF(__pyx_n_u_w); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_n_u_w)) __PYX_ERR(0, 4630, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_enter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4630, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4630, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + __pyx_v_f = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4631 + * # triggered early and in python not in C, Cython or SCIP. + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPprintBestTransSol(self._scip, cfile, write_zeros)) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4631, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4631, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4631, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cfile = fdopen(__pyx_t_5, ((char const *)"w")); + + /* "src/pyscipopt/scip.pxi":4632 + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintBestTransSol(self._scip, cfile, write_zeros)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4632, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_write_zeros); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4632, __pyx_L7_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintBestTransSol(__pyx_v_self->_scip, __pyx_v_cfile, __pyx_t_10)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4632, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4632, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4630 + * # use this double opening pattern to ensure that IOErrors are + * # triggered early and in python not in C, Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintBestTransSol(self._scip, cfile, write_zeros)) + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + /*except:*/ { + __Pyx_AddTraceback("pyscipopt.scip.Model.writeBestTransSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 4630, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4630, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4630, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_12 < 0) __PYX_ERR(0, 4630, __pyx_L9_except_error) + __pyx_t_13 = (!__pyx_t_12); + if (unlikely(__pyx_t_13)) { + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_4); + __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 4630, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_6) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__107, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "src/pyscipopt/scip.pxi":4634 + * PY_SCIP_CALL(SCIPprintBestTransSol(self._scip, cfile, write_zeros)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def writeSol(self, Solution solution, filename="origprob.sol", write_zeros=False): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4618 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeBestTransSol(self, filename="transprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the best feasible primal solution for the transformed problem to a file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeBestTransSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_f); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4636 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeSol(self, Solution solution, filename="origprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the given primal solution to a file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_533writeSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_532writeSol, "Model.writeSol(self, Solution solution, filename=u'origprob.sol', write_zeros=False)\nWrite the given primal solution to a file.\n\n Keyword arguments:\n solution -- solution to write\n filename -- name of the output file\n write_zeros -- include variables that are set to zero\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_533writeSol = {"writeSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_533writeSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_532writeSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_533writeSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_write_zeros = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_filename,&__pyx_n_s_write_zeros,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_origprob_sol)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4636, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4636, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_write_zeros); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4636, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeSol") < 0)) __PYX_ERR(0, 4636, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_filename = values[1]; + __pyx_v_write_zeros = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeSol", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 4636, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 4636, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_532writeSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution, __pyx_v_filename, __pyx_v_write_zeros); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_532writeSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_filename, PyObject *__pyx_v_write_zeros) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_f = NULL; + FILE *__pyx_v_cfile; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + SCIP_Bool __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeSol", 1); + + /* "src/pyscipopt/scip.pxi":4644 + * write_zeros -- include variables that are set to zero + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4644, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4645 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * # use this doubled opening pattern to ensure that IOErrors are + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4645, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4645, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4645, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4645, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4645, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4649 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, cfile, write_zeros)) + */ + /*with:*/ { + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_filename)) __PYX_ERR(0, 4649, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_u_w); + __Pyx_GIVEREF(__pyx_n_u_w); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_n_u_w)) __PYX_ERR(0, 4649, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_enter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4649, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4649, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + __pyx_v_f = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4650 + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, cfile, write_zeros)) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4650, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4650, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4650, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cfile = fdopen(__pyx_t_5, ((char const *)"w")); + + /* "src/pyscipopt/scip.pxi":4651 + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, cfile, write_zeros)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4651, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_write_zeros); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4651, __pyx_L7_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintSol(__pyx_v_self->_scip, __pyx_v_solution->sol, __pyx_v_cfile, __pyx_t_10)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4651, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4651, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4649 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, cfile, write_zeros)) + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + /*except:*/ { + __Pyx_AddTraceback("pyscipopt.scip.Model.writeSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 4649, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4649, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4649, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_12 < 0) __PYX_ERR(0, 4649, __pyx_L9_except_error) + __pyx_t_13 = (!__pyx_t_12); + if (unlikely(__pyx_t_13)) { + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_4); + __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 4649, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_6) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__107, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "src/pyscipopt/scip.pxi":4653 + * PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, cfile, write_zeros)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def writeTransSol(self, Solution solution, filename="transprob.sol", write_zeros=False): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4653, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4636 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeSol(self, Solution solution, filename="origprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the given primal solution to a file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_f); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4655 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeTransSol(self, Solution solution, filename="transprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the given transformed primal solution to a file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_535writeTransSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_534writeTransSol, "Model.writeTransSol(self, Solution solution, filename=u'transprob.sol', write_zeros=False)\nWrite the given transformed primal solution to a file.\n\n Keyword arguments:\n solution -- transformed solution to write\n filename -- name of the output file\n write_zeros -- include variables that are set to zero\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_535writeTransSol = {"writeTransSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_535writeTransSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_534writeTransSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_535writeTransSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_write_zeros = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeTransSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_filename,&__pyx_n_s_write_zeros,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_transprob_sol)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4655, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4655, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_write_zeros); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4655, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeTransSol") < 0)) __PYX_ERR(0, 4655, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_filename = values[1]; + __pyx_v_write_zeros = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeTransSol", 0, 1, 3, __pyx_nargs); __PYX_ERR(0, 4655, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeTransSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 4655, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_534writeTransSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution, __pyx_v_filename, __pyx_v_write_zeros); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_534writeTransSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_filename, PyObject *__pyx_v_write_zeros) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_f = NULL; + FILE *__pyx_v_cfile; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + SCIP_Bool __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeTransSol", 1); + + /* "src/pyscipopt/scip.pxi":4663 + * write_zeros -- include variables that are set to zero + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4663, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4664 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * # use this doubled opening pattern to ensure that IOErrors are + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4668 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintTransSol(self._scip, solution.sol, cfile, write_zeros)) + */ + /*with:*/ { + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_filename)) __PYX_ERR(0, 4668, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_u_w); + __Pyx_GIVEREF(__pyx_n_u_w); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_n_u_w)) __PYX_ERR(0, 4668, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_enter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4668, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4668, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + __pyx_v_f = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4669 + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPprintTransSol(self._scip, solution.sol, cfile, write_zeros)) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4669, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4669, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4669, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cfile = fdopen(__pyx_t_5, ((char const *)"w")); + + /* "src/pyscipopt/scip.pxi":4670 + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintTransSol(self._scip, solution.sol, cfile, write_zeros)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4670, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_write_zeros); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4670, __pyx_L7_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintTransSol(__pyx_v_self->_scip, __pyx_v_solution->sol, __pyx_v_cfile, __pyx_t_10)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4670, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4670, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":4668 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintTransSol(self._scip, solution.sol, cfile, write_zeros)) + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + /*except:*/ { + __Pyx_AddTraceback("pyscipopt.scip.Model.writeTransSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 4668, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4668, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4668, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (__pyx_t_12 < 0) __PYX_ERR(0, 4668, __pyx_L9_except_error) + __pyx_t_13 = (!__pyx_t_12); + if (unlikely(__pyx_t_13)) { + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_4); + __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 4668, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_6) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__107, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "src/pyscipopt/scip.pxi":4672 + * PY_SCIP_CALL(SCIPprintTransSol(self._scip, solution.sol, cfile, write_zeros)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * # perhaps this should not be included as it implements duplicated functionality + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4655 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeTransSol(self, Solution solution, filename="transprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the given transformed primal solution to a file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeTransSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_f); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4676 + * # perhaps this should not be included as it implements duplicated functionality + * # (as does it's namesake in SCIP) + * def readSol(self, filename): # <<<<<<<<<<<<<< + * """Reads a given solution file, problem has to be transformed in advance. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_537readSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_536readSol, "Model.readSol(self, filename)\nReads a given solution file, problem has to be transformed in advance.\n\n Keyword arguments:\n filename -- name of the input file\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_537readSol = {"readSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_537readSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_536readSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_537readSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4676, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readSol") < 0)) __PYX_ERR(0, 4676, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_filename = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("readSol", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4676, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.readSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_536readSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_536readSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_absfile = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char const *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("readSol", 1); + + /* "src/pyscipopt/scip.pxi":4682 + * filename -- name of the input file + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4682, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4683 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * absfile = str_conversion(abspath(filename)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4685 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * absfile = str_conversion(abspath(filename)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreadSol(self._scip, absfile)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_abspath); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4685, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_absfile = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4686 + * + * absfile = str_conversion(abspath(filename)) + * PY_SCIP_CALL(SCIPreadSol(self._scip, absfile)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC, user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4686, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_absfile); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 4686, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreadSol(__pyx_v_self->_scip, __pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4686, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4686, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4688 + * PY_SCIP_CALL(SCIPreadSol(self._scip, absfile)) + * + * locale.setlocale(locale.LC_NUMERIC, user_locale) # <<<<<<<<<<<<<< + * + * def readSolFile(self, filename): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4676 + * # perhaps this should not be included as it implements duplicated functionality + * # (as does it's namesake in SCIP) + * def readSol(self, filename): # <<<<<<<<<<<<<< + * """Reads a given solution file, problem has to be transformed in advance. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.readSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_absfile); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4690 + * locale.setlocale(locale.LC_NUMERIC, user_locale) + * + * def readSolFile(self, filename): # <<<<<<<<<<<<<< + * """Reads a given solution file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_539readSolFile(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_538readSolFile, "Model.readSolFile(self, filename)\nReads a given solution file.\n\n Solution is created but not added to storage/the model.\n Use 'addSol' OR 'trySol' to add it.\n\n Keyword arguments:\n filename -- name of the input file\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_539readSolFile = {"readSolFile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_539readSolFile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_538readSolFile}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_539readSolFile(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readSolFile (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4690, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readSolFile") < 0)) __PYX_ERR(0, 4690, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_filename = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("readSolFile", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4690, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.readSolFile", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_538readSolFile(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_538readSolFile(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename) { + SCIP_Bool __pyx_v_partial; + SCIP_Bool __pyx_v_error; + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_str_absfile = NULL; + PyObject *__pyx_v_absfile = NULL; + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + char const *__pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("readSolFile", 1); + + /* "src/pyscipopt/scip.pxi":4704 + * cdef Solution solution + * + * str_absfile = abspath(filename) # <<<<<<<<<<<<<< + * absfile = str_conversion(str_absfile) + * solution = self.createSol() + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_abspath); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_filename}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_str_absfile = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4705 + * + * str_absfile = abspath(filename) + * absfile = str_conversion(str_absfile) # <<<<<<<<<<<<<< + * solution = self.createSol() + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_str_absfile}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_absfile = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4706 + * str_absfile = abspath(filename) + * absfile = str_conversion(str_absfile) + * solution = self.createSol() # <<<<<<<<<<<<<< + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createSol); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Solution))))) __PYX_ERR(0, 4706, __pyx_L1_error) + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4708 + * solution = self.createSol() + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_5) < 0) __PYX_ERR(0, 4708, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_5; + __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":4709 + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPreadSolFile(self._scip, absfile, solution.sol, False, &partial, &error)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":4711 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * PY_SCIP_CALL(SCIPreadSolFile(self._scip, absfile, solution.sol, False, &partial, &error)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC, user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_absfile); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 4711, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreadSolFile(__pyx_v_self->_scip, __pyx_t_6, __pyx_v_solution->sol, 0, (&__pyx_v_partial), (&__pyx_v_error))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":4713 + * PY_SCIP_CALL(SCIPreadSolFile(self._scip, absfile, solution.sol, False, &partial, &error)) + * + * locale.setlocale(locale.LC_NUMERIC, user_locale) # <<<<<<<<<<<<<< + * + * if error: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "src/pyscipopt/scip.pxi":4715 + * locale.setlocale(locale.LC_NUMERIC, user_locale) + * + * if error: # <<<<<<<<<<<<<< + * raise Exception("SCIP: reading solution from file " + str_absfile + " failed!") + * + */ + __pyx_t_7 = (__pyx_v_error != 0); + if (unlikely(__pyx_t_7)) { + + /* "src/pyscipopt/scip.pxi":4716 + * + * if error: + * raise Exception("SCIP: reading solution from file " + str_absfile + " failed!") # <<<<<<<<<<<<<< + * + * return solution + */ + __pyx_t_5 = PyNumber_Add(__pyx_kp_u_SCIP_reading_solution_from_file, __pyx_v_str_absfile); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4716, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_kp_u_failed); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4716, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_CallOneArg(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])), __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4716, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 4716, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4715 + * locale.setlocale(locale.LC_NUMERIC, user_locale) + * + * if error: # <<<<<<<<<<<<<< + * raise Exception("SCIP: reading solution from file " + str_absfile + " failed!") + * + */ + } + + /* "src/pyscipopt/scip.pxi":4718 + * raise Exception("SCIP: reading solution from file " + str_absfile + " failed!") + * + * return solution # <<<<<<<<<<<<<< + * + * def setSolVal(self, Solution solution, Variable var, val): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_solution); + __pyx_r = ((PyObject *)__pyx_v_solution); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4690 + * locale.setlocale(locale.LC_NUMERIC, user_locale) + * + * def readSolFile(self, filename): # <<<<<<<<<<<<<< + * """Reads a given solution file. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.readSolFile", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_solution); + __Pyx_XDECREF(__pyx_v_str_absfile); + __Pyx_XDECREF(__pyx_v_absfile); + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4720 + * return solution + * + * def setSolVal(self, Solution solution, Variable var, val): # <<<<<<<<<<<<<< + * """Set a variable in a solution. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_541setSolVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_540setSolVal, "Model.setSolVal(self, Solution solution, Variable var, val)\nSet a variable in a solution.\n\n :param Solution solution: solution to be modified\n :param Variable var: variable in the solution\n :param val: value of the specified variable\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_541setSolVal = {"setSolVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_541setSolVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_540setSolVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_541setSolVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_val = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setSolVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_var,&__pyx_n_s_val,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4720, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4720, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setSolVal", 1, 3, 3, 1); __PYX_ERR(0, 4720, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_val)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4720, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setSolVal", 1, 3, 3, 2); __PYX_ERR(0, 4720, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setSolVal") < 0)) __PYX_ERR(0, 4720, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[1]); + __pyx_v_val = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setSolVal", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 4720, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setSolVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 4720, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4720, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_540setSolVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution, __pyx_v_var, __pyx_v_val); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_540setSolVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_val) { + SCIP_SOL *__pyx_v__sol; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Real __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setSolVal", 1); + + /* "src/pyscipopt/scip.pxi":4729 + * """ + * cdef SCIP_SOL* _sol + * _sol = solution.sol # <<<<<<<<<<<<<< + * + * assert _sol != NULL, "Cannot set value to a freed solution." + */ + __pyx_v__sol = ((SCIP_SOL *)__pyx_v_solution->sol); + + /* "src/pyscipopt/scip.pxi":4731 + * _sol = solution.sol + * + * assert _sol != NULL, "Cannot set value to a freed solution." # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetSolVal(self._scip, _sol, var.scip_var, val)) + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (__pyx_v__sol != NULL); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_Cannot_set_value_to_a_freed_solu, 0, 0); + __PYX_ERR(0, 4731, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 4731, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":4732 + * + * assert _sol != NULL, "Cannot set value to a freed solution." + * PY_SCIP_CALL(SCIPsetSolVal(self._scip, _sol, var.scip_var, val)) # <<<<<<<<<<<<<< + * + * def trySol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, free=True): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4732, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_v_val); if (unlikely((__pyx_t_4 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4732, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetSolVal(__pyx_v_self->_scip, __pyx_v__sol, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4732, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4732, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4720 + * return solution + * + * def setSolVal(self, Solution solution, Variable var, val): # <<<<<<<<<<<<<< + * """Set a variable in a solution. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.setSolVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4734 + * PY_SCIP_CALL(SCIPsetSolVal(self._scip, _sol, var.scip_var, val)) + * + * def trySol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, free=True): # <<<<<<<<<<<<<< + * """Check given primal solution for feasibility and try to add it to the storage. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_543trySol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_542trySol, "Model.trySol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, free=True)\nCheck given primal solution for feasibility and try to add it to the storage.\n\n :param Solution solution: solution to store\n :param printreason: should all reasons of violations be printed? (Default value = True)\n :param completely: should all violation be checked? (Default value = False)\n :param checkbounds: should the bounds of the variables be checked? (Default value = True)\n :param checkintegrality: has integrality to be checked? (Default value = True)\n :param checklprows: have current LP rows (both local and global) to be checked? (Default value = True)\n :param free: should solution be freed? (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_543trySol = {"trySol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_543trySol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_542trySol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_543trySol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_printreason = 0; + PyObject *__pyx_v_completely = 0; + PyObject *__pyx_v_checkbounds = 0; + PyObject *__pyx_v_checkintegrality = 0; + PyObject *__pyx_v_checklprows = 0; + PyObject *__pyx_v_free = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[7] = {0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("trySol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_printreason,&__pyx_n_s_completely,&__pyx_n_s_checkbounds,&__pyx_n_s_checkintegrality,&__pyx_n_s_checklprows,&__pyx_n_s_free,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4734, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_printreason); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4734, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_completely); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4734, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checkbounds); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4734, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checkintegrality); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4734, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checklprows); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4734, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_free); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4734, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "trySol") < 0)) __PYX_ERR(0, 4734, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_printreason = values[1]; + __pyx_v_completely = values[2]; + __pyx_v_checkbounds = values[3]; + __pyx_v_checkintegrality = values[4]; + __pyx_v_checklprows = values[5]; + __pyx_v_free = values[6]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("trySol", 0, 1, 7, __pyx_nargs); __PYX_ERR(0, 4734, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.trySol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 4734, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_542trySol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution, __pyx_v_printreason, __pyx_v_completely, __pyx_v_checkbounds, __pyx_v_checkintegrality, __pyx_v_checklprows, __pyx_v_free); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_542trySol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_printreason, PyObject *__pyx_v_completely, PyObject *__pyx_v_checkbounds, PyObject *__pyx_v_checkintegrality, PyObject *__pyx_v_checklprows, PyObject *__pyx_v_free) { + SCIP_Bool __pyx_v_stored; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Bool __pyx_t_4; + SCIP_Bool __pyx_t_5; + SCIP_Bool __pyx_t_6; + SCIP_Bool __pyx_t_7; + SCIP_Bool __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("trySol", 1); + + /* "src/pyscipopt/scip.pxi":4747 + * """ + * cdef SCIP_Bool stored + * if free: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPtrySolFree(self._scip, &solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored)) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_free); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4747, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4748 + * cdef SCIP_Bool stored + * if free: + * PY_SCIP_CALL(SCIPtrySolFree(self._scip, &solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPtrySol(self._scip, solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_printreason); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4748, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_completely); if (unlikely((__pyx_t_5 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4748, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_checkbounds); if (unlikely((__pyx_t_6 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4748, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_checkintegrality); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4748, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_checklprows); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4748, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPtrySolFree(__pyx_v_self->_scip, (&__pyx_v_solution->sol), __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, (&__pyx_v_stored))); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4747 + * """ + * cdef SCIP_Bool stored + * if free: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPtrySolFree(self._scip, &solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":4750 + * PY_SCIP_CALL(SCIPtrySolFree(self._scip, &solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored)) + * else: + * PY_SCIP_CALL(SCIPtrySol(self._scip, solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored)) # <<<<<<<<<<<<<< + * return stored + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_printreason); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4750, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_completely); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4750, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_checkbounds); if (unlikely((__pyx_t_6 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4750, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_checkintegrality); if (unlikely((__pyx_t_5 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4750, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_checklprows); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4750, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPtrySol(__pyx_v_self->_scip, __pyx_v_solution->sol, __pyx_t_8, __pyx_t_7, __pyx_t_6, __pyx_t_5, __pyx_t_4, (&__pyx_v_stored))); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = NULL; + __pyx_t_11 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_10)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_10); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_11 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_10, __pyx_t_9}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_11, 1+__pyx_t_11); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":4751 + * else: + * PY_SCIP_CALL(SCIPtrySol(self._scip, solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored)) + * return stored # <<<<<<<<<<<<<< + * + * def checkSol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, original=False): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_stored); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4751, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4734 + * PY_SCIP_CALL(SCIPsetSolVal(self._scip, _sol, var.scip_var, val)) + * + * def trySol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, free=True): # <<<<<<<<<<<<<< + * """Check given primal solution for feasibility and try to add it to the storage. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("pyscipopt.scip.Model.trySol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4753 + * return stored + * + * def checkSol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, original=False): # <<<<<<<<<<<<<< + * """Check given primal solution for feasibility without adding it to the storage. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_545checkSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_544checkSol, "Model.checkSol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, original=False)\nCheck given primal solution for feasibility without adding it to the storage.\n\n :param Solution solution: solution to store\n :param printreason: should all reasons of violations be printed? (Default value = True)\n :param completely: should all violation be checked? (Default value = False)\n :param checkbounds: should the bounds of the variables be checked? (Default value = True)\n :param checkintegrality: has integrality to be checked? (Default value = True)\n :param checklprows: have current LP rows (both local and global) to be checked? (Default value = True)\n :param original: must the solution be checked against the original problem (Default value = False)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_545checkSol = {"checkSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_545checkSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_544checkSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_545checkSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_printreason = 0; + PyObject *__pyx_v_completely = 0; + PyObject *__pyx_v_checkbounds = 0; + PyObject *__pyx_v_checkintegrality = 0; + PyObject *__pyx_v_checklprows = 0; + PyObject *__pyx_v_original = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[7] = {0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("checkSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_printreason,&__pyx_n_s_completely,&__pyx_n_s_checkbounds,&__pyx_n_s_checkintegrality,&__pyx_n_s_checklprows,&__pyx_n_s_original,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[4] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[5] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4753, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_printreason); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4753, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_completely); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4753, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checkbounds); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4753, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checkintegrality); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4753, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 5: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_checklprows); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4753, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 6: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_original); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4753, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "checkSol") < 0)) __PYX_ERR(0, 4753, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); + CYTHON_FALLTHROUGH; + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); + CYTHON_FALLTHROUGH; + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_printreason = values[1]; + __pyx_v_completely = values[2]; + __pyx_v_checkbounds = values[3]; + __pyx_v_checkintegrality = values[4]; + __pyx_v_checklprows = values[5]; + __pyx_v_original = values[6]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("checkSol", 0, 1, 7, __pyx_nargs); __PYX_ERR(0, 4753, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.checkSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 4753, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_544checkSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution, __pyx_v_printreason, __pyx_v_completely, __pyx_v_checkbounds, __pyx_v_checkintegrality, __pyx_v_checklprows, __pyx_v_original); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_544checkSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_printreason, PyObject *__pyx_v_completely, PyObject *__pyx_v_checkbounds, PyObject *__pyx_v_checkintegrality, PyObject *__pyx_v_checklprows, PyObject *__pyx_v_original) { + SCIP_Bool __pyx_v_feasible; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + SCIP_Bool __pyx_t_4; + SCIP_Bool __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + SCIP_Bool __pyx_t_9; + SCIP_Bool __pyx_t_10; + SCIP_Bool __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("checkSol", 1); + + /* "src/pyscipopt/scip.pxi":4766 + * """ + * cdef SCIP_Bool feasible + * if original: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcheckSolOrig(self._scip, solution.sol, &feasible, printreason, completely)) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_original); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4766, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4767 + * cdef SCIP_Bool feasible + * if original: + * PY_SCIP_CALL(SCIPcheckSolOrig(self._scip, solution.sol, &feasible, printreason, completely)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPcheckSol(self._scip, solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &feasible)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_printreason); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4767, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_completely); if (unlikely((__pyx_t_5 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4767, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcheckSolOrig(__pyx_v_self->_scip, __pyx_v_solution->sol, (&__pyx_v_feasible), __pyx_t_4, __pyx_t_5)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4766 + * """ + * cdef SCIP_Bool feasible + * if original: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcheckSolOrig(self._scip, solution.sol, &feasible, printreason, completely)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":4769 + * PY_SCIP_CALL(SCIPcheckSolOrig(self._scip, solution.sol, &feasible, printreason, completely)) + * else: + * PY_SCIP_CALL(SCIPcheckSol(self._scip, solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &feasible)) # <<<<<<<<<<<<<< + * return feasible + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4769, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_printreason); if (unlikely((__pyx_t_5 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4769, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_completely); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4769, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_checkbounds); if (unlikely((__pyx_t_9 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4769, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_checkintegrality); if (unlikely((__pyx_t_10 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4769, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_checklprows); if (unlikely((__pyx_t_11 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 4769, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcheckSol(__pyx_v_self->_scip, __pyx_v_solution->sol, __pyx_t_5, __pyx_t_4, __pyx_t_9, __pyx_t_10, __pyx_t_11, (&__pyx_v_feasible))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4769, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4769, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":4770 + * else: + * PY_SCIP_CALL(SCIPcheckSol(self._scip, solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &feasible)) + * return feasible # <<<<<<<<<<<<<< + * + * def addSol(self, Solution solution, free=True): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_feasible); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4770, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4753 + * return stored + * + * def checkSol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, original=False): # <<<<<<<<<<<<<< + * """Check given primal solution for feasibility without adding it to the storage. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.checkSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4772 + * return feasible + * + * def addSol(self, Solution solution, free=True): # <<<<<<<<<<<<<< + * """Try to add a solution to the storage. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_547addSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_546addSol, "Model.addSol(self, Solution solution, free=True)\nTry to add a solution to the storage.\n\n :param Solution solution: solution to store\n :param free: should solution be freed afterwards? (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_547addSol = {"addSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_547addSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_546addSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_547addSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + PyObject *__pyx_v_free = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("addSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,&__pyx_n_s_free,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4772, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_free); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4772, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "addSol") < 0)) __PYX_ERR(0, 4772, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_free = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("addSol", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 4772, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.addSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 4772, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_546addSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution, __pyx_v_free); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_546addSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution, PyObject *__pyx_v_free) { + SCIP_Bool __pyx_v_stored; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("addSol", 1); + + /* "src/pyscipopt/scip.pxi":4780 + * """ + * cdef SCIP_Bool stored + * if free: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddSolFree(self._scip, &solution.sol, &stored)) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_free); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4780, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4781 + * cdef SCIP_Bool stored + * if free: + * PY_SCIP_CALL(SCIPaddSolFree(self._scip, &solution.sol, &stored)) # <<<<<<<<<<<<<< + * else: + * PY_SCIP_CALL(SCIPaddSol(self._scip, solution.sol, &stored)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddSolFree(__pyx_v_self->_scip, (&__pyx_v_solution->sol), (&__pyx_v_stored))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4781, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4780 + * """ + * cdef SCIP_Bool stored + * if free: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPaddSolFree(self._scip, &solution.sol, &stored)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":4783 + * PY_SCIP_CALL(SCIPaddSolFree(self._scip, &solution.sol, &stored)) + * else: + * PY_SCIP_CALL(SCIPaddSol(self._scip, solution.sol, &stored)) # <<<<<<<<<<<<<< + * return stored + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPaddSol(__pyx_v_self->_scip, __pyx_v_solution->sol, (&__pyx_v_stored))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":4784 + * else: + * PY_SCIP_CALL(SCIPaddSol(self._scip, solution.sol, &stored)) + * return stored # <<<<<<<<<<<<<< + * + * def freeSol(self, Solution solution): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_stored); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4772 + * return feasible + * + * def addSol(self, Solution solution, free=True): # <<<<<<<<<<<<<< + * """Try to add a solution to the storage. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.addSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4786 + * return stored + * + * def freeSol(self, Solution solution): # <<<<<<<<<<<<<< + * """Free given solution + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_549freeSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_548freeSol, "Model.freeSol(self, Solution solution)\nFree given solution\n\n :param Solution solution: solution to be freed\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_549freeSol = {"freeSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_549freeSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_548freeSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_549freeSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("freeSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_solution,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_solution)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4786, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "freeSol") < 0)) __PYX_ERR(0, 4786, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_solution = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("freeSol", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4786, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.freeSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_solution), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "solution", 0))) __PYX_ERR(0, 4786, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_548freeSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_solution); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_548freeSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_solution) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("freeSol", 1); + + /* "src/pyscipopt/scip.pxi":4792 + * + * """ + * PY_SCIP_CALL(SCIPfreeSol(self._scip, &solution.sol)) # <<<<<<<<<<<<<< + * + * def getNSols(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4792, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPfreeSol(__pyx_v_self->_scip, (&__pyx_v_solution->sol))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4792, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4792, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4786 + * return stored + * + * def freeSol(self, Solution solution): # <<<<<<<<<<<<<< + * """Free given solution + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.freeSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4794 + * PY_SCIP_CALL(SCIPfreeSol(self._scip, &solution.sol)) + * + * def getNSols(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions stored in the solution storage in case the problem is transformed; + * in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_551getNSols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_550getNSols, "Model.getNSols(self)\ngets number of feasible primal solutions stored in the solution storage in case the problem is transformed;\n in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate\n storage is returned\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_551getNSols = {"getNSols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_551getNSols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_550getNSols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_551getNSols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNSols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNSols", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNSols", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_550getNSols(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_550getNSols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNSols", 1); + + /* "src/pyscipopt/scip.pxi":4799 + * storage is returned + * """ + * return SCIPgetNSols(self._scip) # <<<<<<<<<<<<<< + * + * def getNSolsFound(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNSols(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4794 + * PY_SCIP_CALL(SCIPfreeSol(self._scip, &solution.sol)) + * + * def getNSols(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions stored in the solution storage in case the problem is transformed; + * in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNSols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4801 + * return SCIPgetNSols(self._scip) + * + * def getNSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions found so far""" + * return SCIPgetNSolsFound(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_553getNSolsFound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_552getNSolsFound, "Model.getNSolsFound(self)\ngets number of feasible primal solutions found so far"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_553getNSolsFound = {"getNSolsFound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_553getNSolsFound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_552getNSolsFound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_553getNSolsFound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNSolsFound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNSolsFound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNSolsFound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_552getNSolsFound(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_552getNSolsFound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNSolsFound", 1); + + /* "src/pyscipopt/scip.pxi":4803 + * def getNSolsFound(self): + * """gets number of feasible primal solutions found so far""" + * return SCIPgetNSolsFound(self._scip) # <<<<<<<<<<<<<< + * + * def getNLimSolsFound(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNSolsFound(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4803, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4801 + * return SCIPgetNSols(self._scip) + * + * def getNSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions found so far""" + * return SCIPgetNSolsFound(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNSolsFound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4805 + * return SCIPgetNSolsFound(self._scip) + * + * def getNLimSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions respecting the objective limit found so far""" + * return SCIPgetNLimSolsFound(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_555getNLimSolsFound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_554getNLimSolsFound, "Model.getNLimSolsFound(self)\ngets number of feasible primal solutions respecting the objective limit found so far"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_555getNLimSolsFound = {"getNLimSolsFound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_555getNLimSolsFound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_554getNLimSolsFound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_555getNLimSolsFound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNLimSolsFound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNLimSolsFound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLimSolsFound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_554getNLimSolsFound(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_554getNLimSolsFound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNLimSolsFound", 1); + + /* "src/pyscipopt/scip.pxi":4807 + * def getNLimSolsFound(self): + * """gets number of feasible primal solutions respecting the objective limit found so far""" + * return SCIPgetNLimSolsFound(self._scip) # <<<<<<<<<<<<<< + * + * def getNBestSolsFound(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNLimSolsFound(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4807, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4805 + * return SCIPgetNSolsFound(self._scip) + * + * def getNLimSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions respecting the objective limit found so far""" + * return SCIPgetNLimSolsFound(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNLimSolsFound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4809 + * return SCIPgetNLimSolsFound(self._scip) + * + * def getNBestSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found""" + * return SCIPgetNBestSolsFound(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_557getNBestSolsFound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_556getNBestSolsFound, "Model.getNBestSolsFound(self)\ngets number of feasible primal solutions found so far, that improved the primal bound at the time they were found"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_557getNBestSolsFound = {"getNBestSolsFound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_557getNBestSolsFound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_556getNBestSolsFound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_557getNBestSolsFound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNBestSolsFound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNBestSolsFound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNBestSolsFound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_556getNBestSolsFound(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_556getNBestSolsFound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNBestSolsFound", 1); + + /* "src/pyscipopt/scip.pxi":4811 + * def getNBestSolsFound(self): + * """gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found""" + * return SCIPgetNBestSolsFound(self._scip) # <<<<<<<<<<<<<< + * + * def getSols(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNBestSolsFound(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4811, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4809 + * return SCIPgetNLimSolsFound(self._scip) + * + * def getNBestSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found""" + * return SCIPgetNBestSolsFound(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNBestSolsFound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4813 + * return SCIPgetNBestSolsFound(self._scip) + * + * def getSols(self): # <<<<<<<<<<<<<< + * """Retrieve list of all feasible primal solutions stored in the solution storage.""" + * cdef SCIP_SOL** _sols + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_559getSols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_558getSols, "Model.getSols(self)\nRetrieve list of all feasible primal solutions stored in the solution storage."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_559getSols = {"getSols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_559getSols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_558getSols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_559getSols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getSols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getSols", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getSols", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_558getSols(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_558getSols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_SOL **__pyx_v__sols; + int __pyx_v_nsols; + PyObject *__pyx_v_sols = NULL; + int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getSols", 1); + + /* "src/pyscipopt/scip.pxi":4817 + * cdef SCIP_SOL** _sols + * cdef SCIP_SOL* _sol + * _sols = SCIPgetSols(self._scip) # <<<<<<<<<<<<<< + * nsols = SCIPgetNSols(self._scip) + * sols = [] + */ + __pyx_v__sols = SCIPgetSols(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":4818 + * cdef SCIP_SOL* _sol + * _sols = SCIPgetSols(self._scip) + * nsols = SCIPgetNSols(self._scip) # <<<<<<<<<<<<<< + * sols = [] + * + */ + __pyx_v_nsols = SCIPgetNSols(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":4819 + * _sols = SCIPgetSols(self._scip) + * nsols = SCIPgetNSols(self._scip) + * sols = [] # <<<<<<<<<<<<<< + * + * for i in range(nsols): + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_sols = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4821 + * sols = [] + * + * for i in range(nsols): # <<<<<<<<<<<<<< + * sols.append(Solution.create(self._scip, _sols[i])) + * + */ + __pyx_t_2 = __pyx_v_nsols; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/scip.pxi":4822 + * + * for i in range(nsols): + * sols.append(Solution.create(self._scip, _sols[i])) # <<<<<<<<<<<<<< + * + * return sols + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, (__pyx_v__sols[__pyx_v_i])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_sols, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 4822, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/scip.pxi":4824 + * sols.append(Solution.create(self._scip, _sols[i])) + * + * return sols # <<<<<<<<<<<<<< + * + * def getBestSol(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_sols); + __pyx_r = __pyx_v_sols; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4813 + * return SCIPgetNBestSolsFound(self._scip) + * + * def getSols(self): # <<<<<<<<<<<<<< + * """Retrieve list of all feasible primal solutions stored in the solution storage.""" + * cdef SCIP_SOL** _sols + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getSols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_sols); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4826 + * return sols + * + * def getBestSol(self): # <<<<<<<<<<<<<< + * """Retrieve currently best known feasible primal solution.""" + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_561getBestSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_560getBestSol, "Model.getBestSol(self)\nRetrieve currently best known feasible primal solution."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_561getBestSol = {"getBestSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_561getBestSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_560getBestSol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_561getBestSol(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getBestSol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getBestSol", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getBestSol", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_560getBestSol(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_560getBestSol(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getBestSol", 1); + + /* "src/pyscipopt/scip.pxi":4828 + * def getBestSol(self): + * """Retrieve currently best known feasible primal solution.""" + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) # <<<<<<<<<<<<<< + * return self._bestSol + * + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, SCIPgetBestSol(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Solution))))) __PYX_ERR(0, 4828, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->_bestSol); + __Pyx_DECREF((PyObject *)__pyx_v_self->_bestSol); + __pyx_v_self->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4829 + * """Retrieve currently best known feasible primal solution.""" + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * return self._bestSol # <<<<<<<<<<<<<< + * + * def getSolObjVal(self, Solution sol, original=True): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->_bestSol); + __pyx_r = ((PyObject *)__pyx_v_self->_bestSol); + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4826 + * return sols + * + * def getBestSol(self): # <<<<<<<<<<<<<< + * """Retrieve currently best known feasible primal solution.""" + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getBestSol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4831 + * return self._bestSol + * + * def getSolObjVal(self, Solution sol, original=True): # <<<<<<<<<<<<<< + * """Retrieve the objective value of the solution. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_563getSolObjVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_562getSolObjVal, "Model.getSolObjVal(self, Solution sol, original=True)\nRetrieve the objective value of the solution.\n\n :param Solution sol: solution\n :param original: objective value in original space (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_563getSolObjVal = {"getSolObjVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_563getSolObjVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_562getSolObjVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_563getSolObjVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + PyObject *__pyx_v_original = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getSolObjVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sol,&__pyx_n_s_original,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4831, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_original); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4831, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getSolObjVal") < 0)) __PYX_ERR(0, 4831, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_original = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getSolObjVal", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 4831, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getSolObjVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 4831, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_562getSolObjVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_sol, __pyx_v_original); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_562getSolObjVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol, PyObject *__pyx_v_original) { + PyObject *__pyx_v_objval = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getSolObjVal", 0); + __Pyx_INCREF((PyObject *)__pyx_v_sol); + + /* "src/pyscipopt/scip.pxi":4838 + * + * """ + * if sol == None: # <<<<<<<<<<<<<< + * sol = Solution.create(self._scip, NULL) + * sol._checkStage("getSolObjVal") + */ + __pyx_t_1 = PyObject_RichCompare(((PyObject *)__pyx_v_sol), Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4838, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4838, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":4839 + * """ + * if sol == None: + * sol = Solution.create(self._scip, NULL) # <<<<<<<<<<<<<< + * sol._checkStage("getSolObjVal") + * if original: + */ + __pyx_t_1 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Solution))))) __PYX_ERR(0, 4839, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_sol, ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4838 + * + * """ + * if sol == None: # <<<<<<<<<<<<<< + * sol = Solution.create(self._scip, NULL) + * sol._checkStage("getSolObjVal") + */ + } + + /* "src/pyscipopt/scip.pxi":4840 + * if sol == None: + * sol = Solution.create(self._scip, NULL) + * sol._checkStage("getSolObjVal") # <<<<<<<<<<<<<< + * if original: + * objval = SCIPgetSolOrigObj(self._scip, sol.sol) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_sol), __pyx_n_s_checkStage); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4840, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_n_u_getSolObjVal}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4840, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4841 + * sol = Solution.create(self._scip, NULL) + * sol._checkStage("getSolObjVal") + * if original: # <<<<<<<<<<<<<< + * objval = SCIPgetSolOrigObj(self._scip, sol.sol) + * else: + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_original); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4841, __pyx_L1_error) + if (__pyx_t_2) { + + /* "src/pyscipopt/scip.pxi":4842 + * sol._checkStage("getSolObjVal") + * if original: + * objval = SCIPgetSolOrigObj(self._scip, sol.sol) # <<<<<<<<<<<<<< + * else: + * objval = SCIPgetSolTransObj(self._scip, sol.sol) + */ + __pyx_t_1 = PyFloat_FromDouble(SCIPgetSolOrigObj(__pyx_v_self->_scip, __pyx_v_sol->sol)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4842, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_objval = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4841 + * sol = Solution.create(self._scip, NULL) + * sol._checkStage("getSolObjVal") + * if original: # <<<<<<<<<<<<<< + * objval = SCIPgetSolOrigObj(self._scip, sol.sol) + * else: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":4844 + * objval = SCIPgetSolOrigObj(self._scip, sol.sol) + * else: + * objval = SCIPgetSolTransObj(self._scip, sol.sol) # <<<<<<<<<<<<<< + * return objval + * + */ + /*else*/ { + __pyx_t_1 = PyFloat_FromDouble(SCIPgetSolTransObj(__pyx_v_self->_scip, __pyx_v_sol->sol)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4844, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_objval = __pyx_t_1; + __pyx_t_1 = 0; + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":4845 + * else: + * objval = SCIPgetSolTransObj(self._scip, sol.sol) + * return objval # <<<<<<<<<<<<<< + * + * def getSolTime(self, Solution sol): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_objval); + __pyx_r = __pyx_v_objval; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4831 + * return self._bestSol + * + * def getSolObjVal(self, Solution sol, original=True): # <<<<<<<<<<<<<< + * """Retrieve the objective value of the solution. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.getSolObjVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_objval); + __Pyx_XDECREF((PyObject *)__pyx_v_sol); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4847 + * return objval + * + * def getSolTime(self, Solution sol): # <<<<<<<<<<<<<< + * """Get clock time, when this solution was found. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_565getSolTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_564getSolTime, "Model.getSolTime(self, Solution sol)\nGet clock time, when this solution was found.\n\n :param Solution sol: solution\n \n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_565getSolTime = {"getSolTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_565getSolTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_564getSolTime}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_565getSolTime(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getSolTime (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sol,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4847, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getSolTime") < 0)) __PYX_ERR(0, 4847, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getSolTime", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4847, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getSolTime", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 4847, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_564getSolTime(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_sol); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_564getSolTime(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getSolTime", 1); + + /* "src/pyscipopt/scip.pxi":4853 + * + * """ + * return SCIPgetSolTime(self._scip, sol.sol) # <<<<<<<<<<<<<< + * + * def getObjVal(self, original=True): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetSolTime(__pyx_v_self->_scip, __pyx_v_sol->sol)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4847 + * return objval + * + * def getSolTime(self, Solution sol): # <<<<<<<<<<<<<< + * """Get clock time, when this solution was found. + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getSolTime", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4855 + * return SCIPgetSolTime(self._scip, sol.sol) + * + * def getObjVal(self, original=True): # <<<<<<<<<<<<<< + * """Retrieve the objective value of value of best solution. + * Can only be called after solving is completed. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_567getObjVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_566getObjVal, "Model.getObjVal(self, original=True)\nRetrieve the objective value of value of best solution.\n Can only be called after solving is completed.\n\n :param original: objective value in original space (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_567getObjVal = {"getObjVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_567getObjVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_566getObjVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_567getObjVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_original = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getObjVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_original,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_original); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4855, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getObjVal") < 0)) __PYX_ERR(0, 4855, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_original = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getObjVal", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 4855, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getObjVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_566getObjVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_original); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_566getObjVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_original) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getObjVal", 1); + + /* "src/pyscipopt/scip.pxi":4862 + * + * """ + * if not self.getStage() >= SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning("method cannot be called before problem is solved") + * return self.getSolObjVal(self._bestSol, original) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4862, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4862, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_SOLVING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4862, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4862, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4862, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = (!__pyx_t_5); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":4863 + * """ + * if not self.getStage() >= SCIP_STAGE_SOLVING: + * raise Warning("method cannot be called before problem is solved") # <<<<<<<<<<<<<< + * return self.getSolObjVal(self._bestSol, original) + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4863, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 4863, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4862 + * + * """ + * if not self.getStage() >= SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning("method cannot be called before problem is solved") + * return self.getSolObjVal(self._bestSol, original) + */ + } + + /* "src/pyscipopt/scip.pxi":4864 + * if not self.getStage() >= SCIP_STAGE_SOLVING: + * raise Warning("method cannot be called before problem is solved") + * return self.getSolObjVal(self._bestSol, original) # <<<<<<<<<<<<<< + * + * def getSolVal(self, Solution sol, Expr expr): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getSolObjVal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4864, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self->_bestSol), __pyx_v_original}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4864, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4855 + * return SCIPgetSolTime(self._scip, sol.sol) + * + * def getObjVal(self, original=True): # <<<<<<<<<<<<<< + * """Retrieve the objective value of value of best solution. + * Can only be called after solving is completed. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.getObjVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4866 + * return self.getSolObjVal(self._bestSol, original) + * + * def getSolVal(self, Solution sol, Expr expr): # <<<<<<<<<<<<<< + * """Retrieve value of given variable or expression in the given solution or in + * the LP/pseudo solution if sol == None + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_569getSolVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_568getSolVal, "Model.getSolVal(self, Solution sol, Expr expr)\nRetrieve value of given variable or expression in the given solution or in\n the LP/pseudo solution if sol == None\n\n :param Solution sol: solution\n :param Expr expr: polynomial expression to query the value of\n\n Note: a variable is also an expression\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_569getSolVal = {"getSolVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_569getSolVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_568getSolVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_569getSolVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol = 0; + struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getSolVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sol,&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sol)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4866, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4866, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("getSolVal", 1, 2, 2, 1); __PYX_ERR(0, 4866, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getSolVal") < 0)) __PYX_ERR(0, 4866, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_sol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)values[0]); + __pyx_v_expr = ((struct __pyx_obj_9pyscipopt_4scip_Expr *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getSolVal", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4866, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getSolVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sol), __pyx_ptype_9pyscipopt_4scip_Solution, 1, "sol", 0))) __PYX_ERR(0, 4866, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_expr), __pyx_ptype_9pyscipopt_4scip_Expr, 1, "expr", 0))) __PYX_ERR(0, 4866, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_568getSolVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_sol, __pyx_v_expr); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_568getSolVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Solution *__pyx_v_sol, struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_expr) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getSolVal", 0); + __Pyx_INCREF((PyObject *)__pyx_v_sol); + + /* "src/pyscipopt/scip.pxi":4876 + * """ + * # no need to create a NULL solution wrapper in case we have a variable + * if sol == None and isinstance(expr, Variable): # <<<<<<<<<<<<<< + * var = expr + * return SCIPgetSolVal(self._scip, NULL, var.scip_var) + */ + __pyx_t_2 = PyObject_RichCompare(((PyObject *)__pyx_v_sol), Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4876, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 4876, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_TypeCheck(((PyObject *)__pyx_v_expr), __pyx_ptype_9pyscipopt_4scip_Variable); + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4877 + * # no need to create a NULL solution wrapper in case we have a variable + * if sol == None and isinstance(expr, Variable): + * var = expr # <<<<<<<<<<<<<< + * return SCIPgetSolVal(self._scip, NULL, var.scip_var) + * if sol == None: + */ + __pyx_t_2 = ((PyObject *)__pyx_v_expr); + __Pyx_INCREF(__pyx_t_2); + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4878 + * if sol == None and isinstance(expr, Variable): + * var = expr + * return SCIPgetSolVal(self._scip, NULL, var.scip_var) # <<<<<<<<<<<<<< + * if sol == None: + * sol = Solution.create(self._scip, NULL) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetSolVal(__pyx_v_self->_scip, NULL, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4878, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4876 + * """ + * # no need to create a NULL solution wrapper in case we have a variable + * if sol == None and isinstance(expr, Variable): # <<<<<<<<<<<<<< + * var = expr + * return SCIPgetSolVal(self._scip, NULL, var.scip_var) + */ + } + + /* "src/pyscipopt/scip.pxi":4879 + * var = expr + * return SCIPgetSolVal(self._scip, NULL, var.scip_var) + * if sol == None: # <<<<<<<<<<<<<< + * sol = Solution.create(self._scip, NULL) + * return sol[expr] + */ + __pyx_t_2 = PyObject_RichCompare(((PyObject *)__pyx_v_sol), Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4879, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 4879, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4880 + * return SCIPgetSolVal(self._scip, NULL, var.scip_var) + * if sol == None: + * sol = Solution.create(self._scip, NULL) # <<<<<<<<<<<<<< + * return sol[expr] + * + */ + __pyx_t_2 = __pyx_f_9pyscipopt_4scip_8Solution_create(__pyx_v_self->_scip, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_9pyscipopt_4scip_Solution))))) __PYX_ERR(0, 4880, __pyx_L1_error) + __Pyx_DECREF_SET(__pyx_v_sol, ((struct __pyx_obj_9pyscipopt_4scip_Solution *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4879 + * var = expr + * return SCIPgetSolVal(self._scip, NULL, var.scip_var) + * if sol == None: # <<<<<<<<<<<<<< + * sol = Solution.create(self._scip, NULL) + * return sol[expr] + */ + } + + /* "src/pyscipopt/scip.pxi":4881 + * if sol == None: + * sol = Solution.create(self._scip, NULL) + * return sol[expr] # <<<<<<<<<<<<<< + * + * def getVal(self, Expr expr): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_sol), ((PyObject *)__pyx_v_expr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4881, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4866 + * return self.getSolObjVal(self._bestSol, original) + * + * def getSolVal(self, Solution sol, Expr expr): # <<<<<<<<<<<<<< + * """Retrieve value of given variable or expression in the given solution or in + * the LP/pseudo solution if sol == None + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getSolVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XDECREF((PyObject *)__pyx_v_sol); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4883 + * return sol[expr] + * + * def getVal(self, Expr expr): # <<<<<<<<<<<<<< + * """Retrieve the value of the given variable or expression in the best known solution. + * Can only be called after solving is completed. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_571getVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_570getVal, "Model.getVal(self, Expr expr)\nRetrieve the value of the given variable or expression in the best known solution.\n Can only be called after solving is completed.\n\n :param Expr expr: polynomial expression to query the value of\n\n Note: a variable is also an expression\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_571getVal = {"getVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_571getVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_570getVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_571getVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_expr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_expr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_expr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4883, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getVal") < 0)) __PYX_ERR(0, 4883, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_expr = ((struct __pyx_obj_9pyscipopt_4scip_Expr *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getVal", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4883, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_expr), __pyx_ptype_9pyscipopt_4scip_Expr, 1, "expr", 0))) __PYX_ERR(0, 4883, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_570getVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_expr); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_570getVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v_expr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getVal", 1); + + /* "src/pyscipopt/scip.pxi":4891 + * Note: a variable is also an expression + * """ + * if not self.getStage() >= SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning("method cannot be called before problem is solved") + * return self.getSolVal(self._bestSol, expr) + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStage); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4891, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4891, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_SOLVING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4891, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 4891, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = (!__pyx_t_5); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":4892 + * """ + * if not self.getStage() >= SCIP_STAGE_SOLVING: + * raise Warning("method cannot be called before problem is solved") # <<<<<<<<<<<<<< + * return self.getSolVal(self._bestSol, expr) + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4892, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 4892, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4891 + * Note: a variable is also an expression + * """ + * if not self.getStage() >= SCIP_STAGE_SOLVING: # <<<<<<<<<<<<<< + * raise Warning("method cannot be called before problem is solved") + * return self.getSolVal(self._bestSol, expr) + */ + } + + /* "src/pyscipopt/scip.pxi":4893 + * if not self.getStage() >= SCIP_STAGE_SOLVING: + * raise Warning("method cannot be called before problem is solved") + * return self.getSolVal(self._bestSol, expr) # <<<<<<<<<<<<<< + * + * def hasPrimalRay(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getSolVal); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4893, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self->_bestSol), ((PyObject *)__pyx_v_expr)}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 2+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4893, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4883 + * return sol[expr] + * + * def getVal(self, Expr expr): # <<<<<<<<<<<<<< + * """Retrieve the value of the given variable or expression in the best known solution. + * Can only be called after solving is completed. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.getVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4895 + * return self.getSolVal(self._bestSol, expr) + * + * def hasPrimalRay(self): # <<<<<<<<<<<<<< + * """ + * Returns whether a primal ray is stored that proves unboundedness of the LP relaxation + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_573hasPrimalRay(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_572hasPrimalRay, "Model.hasPrimalRay(self)\n\n Returns whether a primal ray is stored that proves unboundedness of the LP relaxation\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_573hasPrimalRay = {"hasPrimalRay", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_573hasPrimalRay, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_572hasPrimalRay}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_573hasPrimalRay(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("hasPrimalRay (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("hasPrimalRay", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "hasPrimalRay", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_572hasPrimalRay(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_572hasPrimalRay(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("hasPrimalRay", 1); + + /* "src/pyscipopt/scip.pxi":4899 + * Returns whether a primal ray is stored that proves unboundedness of the LP relaxation + * """ + * return SCIPhasPrimalRay(self._scip) # <<<<<<<<<<<<<< + * + * def getPrimalRayVal(self, Variable var): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPhasPrimalRay(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4899, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4895 + * return self.getSolVal(self._bestSol, expr) + * + * def hasPrimalRay(self): # <<<<<<<<<<<<<< + * """ + * Returns whether a primal ray is stored that proves unboundedness of the LP relaxation + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.hasPrimalRay", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4901 + * return SCIPhasPrimalRay(self._scip) + * + * def getPrimalRayVal(self, Variable var): # <<<<<<<<<<<<<< + * """ + * Gets value of given variable in primal ray causing unboundedness of the LP relaxation + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_575getPrimalRayVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_574getPrimalRayVal, "Model.getPrimalRayVal(self, Variable var)\n\n Gets value of given variable in primal ray causing unboundedness of the LP relaxation\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_575getPrimalRayVal = {"getPrimalRayVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_575getPrimalRayVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_574getPrimalRayVal}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_575getPrimalRayVal(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPrimalRayVal (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4901, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getPrimalRayVal") < 0)) __PYX_ERR(0, 4901, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getPrimalRayVal", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4901, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getPrimalRayVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4901, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_574getPrimalRayVal(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_574getPrimalRayVal(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getPrimalRayVal", 1); + + /* "src/pyscipopt/scip.pxi":4905 + * Gets value of given variable in primal ray causing unboundedness of the LP relaxation + * """ + * assert SCIPhasPrimalRay(self._scip), "The problem does not have a primal ray." # <<<<<<<<<<<<<< + * + * return SCIPgetPrimalRayVal(self._scip, var.scip_var) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (SCIPhasPrimalRay(__pyx_v_self->_scip) != 0); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_The_problem_does_not_have_a_prim, 0, 0); + __PYX_ERR(0, 4905, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 4905, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":4907 + * assert SCIPhasPrimalRay(self._scip), "The problem does not have a primal ray." + * + * return SCIPgetPrimalRayVal(self._scip, var.scip_var) # <<<<<<<<<<<<<< + * + * def getPrimalRay(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyFloat_FromDouble(SCIPgetPrimalRayVal(__pyx_v_self->_scip, __pyx_v_var->scip_var)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4907, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4901 + * return SCIPhasPrimalRay(self._scip) + * + * def getPrimalRayVal(self, Variable var): # <<<<<<<<<<<<<< + * """ + * Gets value of given variable in primal ray causing unboundedness of the LP relaxation + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getPrimalRayVal", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4909 + * return SCIPgetPrimalRayVal(self._scip, var.scip_var) + * + * def getPrimalRay(self): # <<<<<<<<<<<<<< + * """ + * Gets primal ray causing unboundedness of the LP relaxation + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_577getPrimalRay(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_576getPrimalRay, "Model.getPrimalRay(self)\n\n Gets primal ray causing unboundedness of the LP relaxation\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_577getPrimalRay = {"getPrimalRay", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_577getPrimalRay, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_576getPrimalRay}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_577getPrimalRay(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPrimalRay (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getPrimalRay", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPrimalRay", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_576getPrimalRay(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_576getPrimalRay(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + int __pyx_v__nvars; + SCIP_VAR **__pyx_v__vars; + PyObject *__pyx_v_ray = NULL; + int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getPrimalRay", 1); + + /* "src/pyscipopt/scip.pxi":4913 + * Gets primal ray causing unboundedness of the LP relaxation + * """ + * assert SCIPhasPrimalRay(self._scip), "The problem does not have a primal ray." # <<<<<<<<<<<<<< + * + * cdef int _nvars = SCIPgetNVars(self._scip) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (SCIPhasPrimalRay(__pyx_v_self->_scip) != 0); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_kp_u_The_problem_does_not_have_a_prim, 0, 0); + __PYX_ERR(0, 4913, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 4913, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":4915 + * assert SCIPhasPrimalRay(self._scip), "The problem does not have a primal ray." + * + * cdef int _nvars = SCIPgetNVars(self._scip) # <<<<<<<<<<<<<< + * cdef SCIP_VAR ** _vars = SCIPgetVars(self._scip) + * + */ + __pyx_v__nvars = SCIPgetNVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":4916 + * + * cdef int _nvars = SCIPgetNVars(self._scip) + * cdef SCIP_VAR ** _vars = SCIPgetVars(self._scip) # <<<<<<<<<<<<<< + * + * ray = [] + */ + __pyx_v__vars = SCIPgetVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":4918 + * cdef SCIP_VAR ** _vars = SCIPgetVars(self._scip) + * + * ray = [] # <<<<<<<<<<<<<< + * for i in range(_nvars): + * ray.append(float(SCIPgetPrimalRayVal(self._scip, _vars[i]))) + */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_ray = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4919 + * + * ray = [] + * for i in range(_nvars): # <<<<<<<<<<<<<< + * ray.append(float(SCIPgetPrimalRayVal(self._scip, _vars[i]))) + * + */ + __pyx_t_3 = __pyx_v__nvars; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "src/pyscipopt/scip.pxi":4920 + * ray = [] + * for i in range(_nvars): + * ray.append(float(SCIPgetPrimalRayVal(self._scip, _vars[i]))) # <<<<<<<<<<<<<< + * + * return ray + */ + __pyx_t_2 = PyFloat_FromDouble(((double)SCIPgetPrimalRayVal(__pyx_v_self->_scip, (__pyx_v__vars[__pyx_v_i])))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_ray, __pyx_t_2); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(0, 4920, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + + /* "src/pyscipopt/scip.pxi":4922 + * ray.append(float(SCIPgetPrimalRayVal(self._scip, _vars[i]))) + * + * return ray # <<<<<<<<<<<<<< + * + * def getPrimalbound(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_ray); + __pyx_r = __pyx_v_ray; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4909 + * return SCIPgetPrimalRayVal(self._scip, var.scip_var) + * + * def getPrimalRay(self): # <<<<<<<<<<<<<< + * """ + * Gets primal ray causing unboundedness of the LP relaxation + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getPrimalRay", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_ray); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4924 + * return ray + * + * def getPrimalbound(self): # <<<<<<<<<<<<<< + * """Retrieve the best primal bound.""" + * return SCIPgetPrimalbound(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_579getPrimalbound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_578getPrimalbound, "Model.getPrimalbound(self)\nRetrieve the best primal bound."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_579getPrimalbound = {"getPrimalbound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_579getPrimalbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_578getPrimalbound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_579getPrimalbound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getPrimalbound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getPrimalbound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getPrimalbound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_578getPrimalbound(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_578getPrimalbound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getPrimalbound", 1); + + /* "src/pyscipopt/scip.pxi":4926 + * def getPrimalbound(self): + * """Retrieve the best primal bound.""" + * return SCIPgetPrimalbound(self._scip) # <<<<<<<<<<<<<< + * + * def getDualbound(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetPrimalbound(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4924 + * return ray + * + * def getPrimalbound(self): # <<<<<<<<<<<<<< + * """Retrieve the best primal bound.""" + * return SCIPgetPrimalbound(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getPrimalbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4928 + * return SCIPgetPrimalbound(self._scip) + * + * def getDualbound(self): # <<<<<<<<<<<<<< + * """Retrieve the best dual bound.""" + * return SCIPgetDualbound(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_581getDualbound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_580getDualbound, "Model.getDualbound(self)\nRetrieve the best dual bound."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_581getDualbound = {"getDualbound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_581getDualbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_580getDualbound}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_581getDualbound(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDualbound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getDualbound", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDualbound", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_580getDualbound(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_580getDualbound(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDualbound", 1); + + /* "src/pyscipopt/scip.pxi":4930 + * def getDualbound(self): + * """Retrieve the best dual bound.""" + * return SCIPgetDualbound(self._scip) # <<<<<<<<<<<<<< + * + * def getDualboundRoot(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetDualbound(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4928 + * return SCIPgetPrimalbound(self._scip) + * + * def getDualbound(self): # <<<<<<<<<<<<<< + * """Retrieve the best dual bound.""" + * return SCIPgetDualbound(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4932 + * return SCIPgetDualbound(self._scip) + * + * def getDualboundRoot(self): # <<<<<<<<<<<<<< + * """Retrieve the best root dual bound.""" + * return SCIPgetDualboundRoot(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_583getDualboundRoot(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_582getDualboundRoot, "Model.getDualboundRoot(self)\nRetrieve the best root dual bound."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_583getDualboundRoot = {"getDualboundRoot", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_583getDualboundRoot, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_582getDualboundRoot}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_583getDualboundRoot(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getDualboundRoot (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getDualboundRoot", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getDualboundRoot", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_582getDualboundRoot(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_582getDualboundRoot(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getDualboundRoot", 1); + + /* "src/pyscipopt/scip.pxi":4934 + * def getDualboundRoot(self): + * """Retrieve the best root dual bound.""" + * return SCIPgetDualboundRoot(self._scip) # <<<<<<<<<<<<<< + * + * def writeName(self, Variable var): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetDualboundRoot(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4934, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4932 + * return SCIPgetDualbound(self._scip) + * + * def getDualboundRoot(self): # <<<<<<<<<<<<<< + * """Retrieve the best root dual bound.""" + * return SCIPgetDualboundRoot(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getDualboundRoot", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4936 + * return SCIPgetDualboundRoot(self._scip) + * + * def writeName(self, Variable var): # <<<<<<<<<<<<<< + * """Write the name of the variable to the std out. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_585writeName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_584writeName, "Model.writeName(self, Variable var)\nWrite the name of the variable to the std out.\n\n :param Variable var: variable\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_585writeName = {"writeName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_585writeName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_584writeName}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_585writeName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeName (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4936, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeName") < 0)) __PYX_ERR(0, 4936, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeName", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 4936, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeName", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 4936, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_584writeName(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_584writeName(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeName", 1); + + /* "src/pyscipopt/scip.pxi":4942 + * + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 4942, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4943 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPwriteVarName(self._scip, NULL, var.scip_var, False)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4945 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * PY_SCIP_CALL(SCIPwriteVarName(self._scip, NULL, var.scip_var, False)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPwriteVarName(__pyx_v_self->_scip, NULL, __pyx_v_var->scip_var, 0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4947 + * PY_SCIP_CALL(SCIPwriteVarName(self._scip, NULL, var.scip_var, False)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def getStage(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":4936 + * return SCIPgetDualboundRoot(self._scip) + * + * def writeName(self, Variable var): # <<<<<<<<<<<<<< + * """Write the name of the variable to the std out. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeName", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4949 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getStage(self): # <<<<<<<<<<<<<< + * """Retrieve current SCIP stage""" + * return SCIPgetStage(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_587getStage(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_586getStage, "Model.getStage(self)\nRetrieve current SCIP stage"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_587getStage = {"getStage", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_587getStage, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_586getStage}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_587getStage(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getStage (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getStage", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getStage", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_586getStage(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_586getStage(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getStage", 1); + + /* "src/pyscipopt/scip.pxi":4951 + * def getStage(self): + * """Retrieve current SCIP stage""" + * return SCIPgetStage(self._scip) # <<<<<<<<<<<<<< + * + * def getStageName(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_STAGE(SCIPgetStage(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4949 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getStage(self): # <<<<<<<<<<<<<< + * """Retrieve current SCIP stage""" + * return SCIPgetStage(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getStage", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4953 + * return SCIPgetStage(self._scip) + * + * def getStageName(self): # <<<<<<<<<<<<<< + * """Returns name of current stage as string""" + * if not StageNames: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_589getStageName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_588getStageName, "Model.getStageName(self)\nReturns name of current stage as string"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_589getStageName = {"getStageName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_589getStageName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_588getStageName}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_589getStageName(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getStageName (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getStageName", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getStageName", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_588getStageName(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_588getStageName(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getStageName", 1); + + /* "src/pyscipopt/scip.pxi":4955 + * def getStageName(self): + * """Returns name of current stage as string""" + * if not StageNames: # <<<<<<<<<<<<<< + * self._getStageNames() + * return StageNames[self.getStage()] + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_StageNames); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4955, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 4955, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (!__pyx_t_2); + if (__pyx_t_3) { + + /* "src/pyscipopt/scip.pxi":4956 + * """Returns name of current stage as string""" + * if not StageNames: + * self._getStageNames() # <<<<<<<<<<<<<< + * return StageNames[self.getStage()] + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStageNames); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4955 + * def getStageName(self): + * """Returns name of current stage as string""" + * if not StageNames: # <<<<<<<<<<<<<< + * self._getStageNames() + * return StageNames[self.getStage()] + */ + } + + /* "src/pyscipopt/scip.pxi":4957 + * if not StageNames: + * self._getStageNames() + * return StageNames[self.getStage()] # <<<<<<<<<<<<<< + * + * def _getStageNames(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_StageNames); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4957, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getStage); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4957, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_6, 0+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4957, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4957, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4953 + * return SCIPgetStage(self._scip) + * + * def getStageName(self): # <<<<<<<<<<<<<< + * """Returns name of current stage as string""" + * if not StageNames: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.getStageName", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4959 + * return StageNames[self.getStage()] + * + * def _getStageNames(self): # <<<<<<<<<<<<<< + * """Gets names of stages""" + * for name in dir(PY_SCIP_STAGE): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_591_getStageNames(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_590_getStageNames, "Model._getStageNames(self)\nGets names of stages"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_591_getStageNames = {"_getStageNames", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_591_getStageNames, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_590_getStageNames}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_591_getStageNames(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_getStageNames (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("_getStageNames", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "_getStageNames", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_590_getStageNames(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_590_getStageNames(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_v_attr = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_getStageNames", 1); + + /* "src/pyscipopt/scip.pxi":4961 + * def _getStageNames(self): + * """Gets names of stages""" + * for name in dir(PY_SCIP_STAGE): # <<<<<<<<<<<<<< + * attr = getattr(PY_SCIP_STAGE, name) + * if isinstance(attr, int): + */ + __pyx_t_1 = PyObject_Dir(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4961, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4961, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 4961, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 4961, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely((0 < 0))) __PYX_ERR(0, 4961, __pyx_L1_error) + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + } + } else { + __pyx_t_1 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 4961, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4962 + * """Gets names of stages""" + * for name in dir(PY_SCIP_STAGE): + * attr = getattr(PY_SCIP_STAGE, name) # <<<<<<<<<<<<<< + * if isinstance(attr, int): + * StageNames[attr] = name + */ + __pyx_t_1 = __Pyx_GetAttr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE), __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_attr, __pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4963 + * for name in dir(PY_SCIP_STAGE): + * attr = getattr(PY_SCIP_STAGE, name) + * if isinstance(attr, int): # <<<<<<<<<<<<<< + * StageNames[attr] = name + * + */ + __pyx_t_5 = PyInt_Check(__pyx_v_attr); + if (__pyx_t_5) { + + /* "src/pyscipopt/scip.pxi":4964 + * attr = getattr(PY_SCIP_STAGE, name) + * if isinstance(attr, int): + * StageNames[attr] = name # <<<<<<<<<<<<<< + * + * def getStatus(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_StageNames); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_attr, __pyx_v_name) < 0))) __PYX_ERR(0, 4964, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":4963 + * for name in dir(PY_SCIP_STAGE): + * attr = getattr(PY_SCIP_STAGE, name) + * if isinstance(attr, int): # <<<<<<<<<<<<<< + * StageNames[attr] = name + * + */ + } + + /* "src/pyscipopt/scip.pxi":4961 + * def _getStageNames(self): + * """Gets names of stages""" + * for name in dir(PY_SCIP_STAGE): # <<<<<<<<<<<<<< + * attr = getattr(PY_SCIP_STAGE, name) + * if isinstance(attr, int): + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4959 + * return StageNames[self.getStage()] + * + * def _getStageNames(self): # <<<<<<<<<<<<<< + * """Gets names of stages""" + * for name in dir(PY_SCIP_STAGE): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model._getStageNames", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_attr); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":4966 + * StageNames[attr] = name + * + * def getStatus(self): # <<<<<<<<<<<<<< + * """Retrieve solution status.""" + * cdef SCIP_STATUS stat = SCIPgetStatus(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_593getStatus(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_592getStatus, "Model.getStatus(self)\nRetrieve solution status."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_593getStatus = {"getStatus", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_593getStatus, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_592getStatus}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_593getStatus(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getStatus (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getStatus", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getStatus", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_592getStatus(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_592getStatus(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_STATUS __pyx_v_stat; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("getStatus", 1); + + /* "src/pyscipopt/scip.pxi":4968 + * def getStatus(self): + * """Retrieve solution status.""" + * cdef SCIP_STATUS stat = SCIPgetStatus(self._scip) # <<<<<<<<<<<<<< + * if stat == SCIP_STATUS_OPTIMAL: + * return "optimal" + */ + __pyx_v_stat = SCIPgetStatus(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":4969 + * """Retrieve solution status.""" + * cdef SCIP_STATUS stat = SCIPgetStatus(self._scip) + * if stat == SCIP_STATUS_OPTIMAL: # <<<<<<<<<<<<<< + * return "optimal" + * elif stat == SCIP_STATUS_TIMELIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_OPTIMAL); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4970 + * cdef SCIP_STATUS stat = SCIPgetStatus(self._scip) + * if stat == SCIP_STATUS_OPTIMAL: + * return "optimal" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_TIMELIMIT: + * return "timelimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_optimal); + __pyx_r = __pyx_n_u_optimal; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4969 + * """Retrieve solution status.""" + * cdef SCIP_STATUS stat = SCIPgetStatus(self._scip) + * if stat == SCIP_STATUS_OPTIMAL: # <<<<<<<<<<<<<< + * return "optimal" + * elif stat == SCIP_STATUS_TIMELIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4971 + * if stat == SCIP_STATUS_OPTIMAL: + * return "optimal" + * elif stat == SCIP_STATUS_TIMELIMIT: # <<<<<<<<<<<<<< + * return "timelimit" + * elif stat == SCIP_STATUS_INFEASIBLE: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_TIMELIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4972 + * return "optimal" + * elif stat == SCIP_STATUS_TIMELIMIT: + * return "timelimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_INFEASIBLE: + * return "infeasible" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_timelimit); + __pyx_r = __pyx_n_u_timelimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4971 + * if stat == SCIP_STATUS_OPTIMAL: + * return "optimal" + * elif stat == SCIP_STATUS_TIMELIMIT: # <<<<<<<<<<<<<< + * return "timelimit" + * elif stat == SCIP_STATUS_INFEASIBLE: + */ + } + + /* "src/pyscipopt/scip.pxi":4973 + * elif stat == SCIP_STATUS_TIMELIMIT: + * return "timelimit" + * elif stat == SCIP_STATUS_INFEASIBLE: # <<<<<<<<<<<<<< + * return "infeasible" + * elif stat == SCIP_STATUS_UNBOUNDED: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_INFEASIBLE); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4974 + * return "timelimit" + * elif stat == SCIP_STATUS_INFEASIBLE: + * return "infeasible" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_UNBOUNDED: + * return "unbounded" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_infeasible); + __pyx_r = __pyx_n_u_infeasible; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4973 + * elif stat == SCIP_STATUS_TIMELIMIT: + * return "timelimit" + * elif stat == SCIP_STATUS_INFEASIBLE: # <<<<<<<<<<<<<< + * return "infeasible" + * elif stat == SCIP_STATUS_UNBOUNDED: + */ + } + + /* "src/pyscipopt/scip.pxi":4975 + * elif stat == SCIP_STATUS_INFEASIBLE: + * return "infeasible" + * elif stat == SCIP_STATUS_UNBOUNDED: # <<<<<<<<<<<<<< + * return "unbounded" + * elif stat == SCIP_STATUS_USERINTERRUPT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_UNBOUNDED); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4976 + * return "infeasible" + * elif stat == SCIP_STATUS_UNBOUNDED: + * return "unbounded" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_USERINTERRUPT: + * return "userinterrupt" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_unbounded); + __pyx_r = __pyx_n_u_unbounded; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4975 + * elif stat == SCIP_STATUS_INFEASIBLE: + * return "infeasible" + * elif stat == SCIP_STATUS_UNBOUNDED: # <<<<<<<<<<<<<< + * return "unbounded" + * elif stat == SCIP_STATUS_USERINTERRUPT: + */ + } + + /* "src/pyscipopt/scip.pxi":4977 + * elif stat == SCIP_STATUS_UNBOUNDED: + * return "unbounded" + * elif stat == SCIP_STATUS_USERINTERRUPT: # <<<<<<<<<<<<<< + * return "userinterrupt" + * elif stat == SCIP_STATUS_INFORUNBD: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_USERINTERRUPT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4978 + * return "unbounded" + * elif stat == SCIP_STATUS_USERINTERRUPT: + * return "userinterrupt" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_INFORUNBD: + * return "inforunbd" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_userinterrupt); + __pyx_r = __pyx_n_u_userinterrupt; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4977 + * elif stat == SCIP_STATUS_UNBOUNDED: + * return "unbounded" + * elif stat == SCIP_STATUS_USERINTERRUPT: # <<<<<<<<<<<<<< + * return "userinterrupt" + * elif stat == SCIP_STATUS_INFORUNBD: + */ + } + + /* "src/pyscipopt/scip.pxi":4979 + * elif stat == SCIP_STATUS_USERINTERRUPT: + * return "userinterrupt" + * elif stat == SCIP_STATUS_INFORUNBD: # <<<<<<<<<<<<<< + * return "inforunbd" + * elif stat == SCIP_STATUS_NODELIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_INFORUNBD); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4980 + * return "userinterrupt" + * elif stat == SCIP_STATUS_INFORUNBD: + * return "inforunbd" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_NODELIMIT: + * return "nodelimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_inforunbd); + __pyx_r = __pyx_n_u_inforunbd; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4979 + * elif stat == SCIP_STATUS_USERINTERRUPT: + * return "userinterrupt" + * elif stat == SCIP_STATUS_INFORUNBD: # <<<<<<<<<<<<<< + * return "inforunbd" + * elif stat == SCIP_STATUS_NODELIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4981 + * elif stat == SCIP_STATUS_INFORUNBD: + * return "inforunbd" + * elif stat == SCIP_STATUS_NODELIMIT: # <<<<<<<<<<<<<< + * return "nodelimit" + * elif stat == SCIP_STATUS_TOTALNODELIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_NODELIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4982 + * return "inforunbd" + * elif stat == SCIP_STATUS_NODELIMIT: + * return "nodelimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_TOTALNODELIMIT: + * return "totalnodelimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_nodelimit); + __pyx_r = __pyx_n_u_nodelimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4981 + * elif stat == SCIP_STATUS_INFORUNBD: + * return "inforunbd" + * elif stat == SCIP_STATUS_NODELIMIT: # <<<<<<<<<<<<<< + * return "nodelimit" + * elif stat == SCIP_STATUS_TOTALNODELIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4983 + * elif stat == SCIP_STATUS_NODELIMIT: + * return "nodelimit" + * elif stat == SCIP_STATUS_TOTALNODELIMIT: # <<<<<<<<<<<<<< + * return "totalnodelimit" + * elif stat == SCIP_STATUS_STALLNODELIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_TOTALNODELIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4984 + * return "nodelimit" + * elif stat == SCIP_STATUS_TOTALNODELIMIT: + * return "totalnodelimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_STALLNODELIMIT: + * return "stallnodelimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_totalnodelimit); + __pyx_r = __pyx_n_u_totalnodelimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4983 + * elif stat == SCIP_STATUS_NODELIMIT: + * return "nodelimit" + * elif stat == SCIP_STATUS_TOTALNODELIMIT: # <<<<<<<<<<<<<< + * return "totalnodelimit" + * elif stat == SCIP_STATUS_STALLNODELIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4985 + * elif stat == SCIP_STATUS_TOTALNODELIMIT: + * return "totalnodelimit" + * elif stat == SCIP_STATUS_STALLNODELIMIT: # <<<<<<<<<<<<<< + * return "stallnodelimit" + * elif stat == SCIP_STATUS_GAPLIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_STALLNODELIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4986 + * return "totalnodelimit" + * elif stat == SCIP_STATUS_STALLNODELIMIT: + * return "stallnodelimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_GAPLIMIT: + * return "gaplimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_stallnodelimit); + __pyx_r = __pyx_n_u_stallnodelimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4985 + * elif stat == SCIP_STATUS_TOTALNODELIMIT: + * return "totalnodelimit" + * elif stat == SCIP_STATUS_STALLNODELIMIT: # <<<<<<<<<<<<<< + * return "stallnodelimit" + * elif stat == SCIP_STATUS_GAPLIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4987 + * elif stat == SCIP_STATUS_STALLNODELIMIT: + * return "stallnodelimit" + * elif stat == SCIP_STATUS_GAPLIMIT: # <<<<<<<<<<<<<< + * return "gaplimit" + * elif stat == SCIP_STATUS_MEMLIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_GAPLIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4988 + * return "stallnodelimit" + * elif stat == SCIP_STATUS_GAPLIMIT: + * return "gaplimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_MEMLIMIT: + * return "memlimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_gaplimit); + __pyx_r = __pyx_n_u_gaplimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4987 + * elif stat == SCIP_STATUS_STALLNODELIMIT: + * return "stallnodelimit" + * elif stat == SCIP_STATUS_GAPLIMIT: # <<<<<<<<<<<<<< + * return "gaplimit" + * elif stat == SCIP_STATUS_MEMLIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4989 + * elif stat == SCIP_STATUS_GAPLIMIT: + * return "gaplimit" + * elif stat == SCIP_STATUS_MEMLIMIT: # <<<<<<<<<<<<<< + * return "memlimit" + * elif stat == SCIP_STATUS_SOLLIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_MEMLIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4990 + * return "gaplimit" + * elif stat == SCIP_STATUS_MEMLIMIT: + * return "memlimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_SOLLIMIT: + * return "sollimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_memlimit); + __pyx_r = __pyx_n_u_memlimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4989 + * elif stat == SCIP_STATUS_GAPLIMIT: + * return "gaplimit" + * elif stat == SCIP_STATUS_MEMLIMIT: # <<<<<<<<<<<<<< + * return "memlimit" + * elif stat == SCIP_STATUS_SOLLIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4991 + * elif stat == SCIP_STATUS_MEMLIMIT: + * return "memlimit" + * elif stat == SCIP_STATUS_SOLLIMIT: # <<<<<<<<<<<<<< + * return "sollimit" + * elif stat == SCIP_STATUS_BESTSOLLIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_SOLLIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4992 + * return "memlimit" + * elif stat == SCIP_STATUS_SOLLIMIT: + * return "sollimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_BESTSOLLIMIT: + * return "bestsollimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_sollimit); + __pyx_r = __pyx_n_u_sollimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4991 + * elif stat == SCIP_STATUS_MEMLIMIT: + * return "memlimit" + * elif stat == SCIP_STATUS_SOLLIMIT: # <<<<<<<<<<<<<< + * return "sollimit" + * elif stat == SCIP_STATUS_BESTSOLLIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4993 + * elif stat == SCIP_STATUS_SOLLIMIT: + * return "sollimit" + * elif stat == SCIP_STATUS_BESTSOLLIMIT: # <<<<<<<<<<<<<< + * return "bestsollimit" + * elif stat == SCIP_STATUS_RESTARTLIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_BESTSOLLIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4994 + * return "sollimit" + * elif stat == SCIP_STATUS_BESTSOLLIMIT: + * return "bestsollimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_RESTARTLIMIT: + * return "restartlimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_bestsollimit); + __pyx_r = __pyx_n_u_bestsollimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4993 + * elif stat == SCIP_STATUS_SOLLIMIT: + * return "sollimit" + * elif stat == SCIP_STATUS_BESTSOLLIMIT: # <<<<<<<<<<<<<< + * return "bestsollimit" + * elif stat == SCIP_STATUS_RESTARTLIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4995 + * elif stat == SCIP_STATUS_BESTSOLLIMIT: + * return "bestsollimit" + * elif stat == SCIP_STATUS_RESTARTLIMIT: # <<<<<<<<<<<<<< + * return "restartlimit" + * elif stat == SCIP_STATUS_PRIMALLIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_RESTARTLIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4996 + * return "bestsollimit" + * elif stat == SCIP_STATUS_RESTARTLIMIT: + * return "restartlimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_PRIMALLIMIT: + * return "primallimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_restartlimit); + __pyx_r = __pyx_n_u_restartlimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4995 + * elif stat == SCIP_STATUS_BESTSOLLIMIT: + * return "bestsollimit" + * elif stat == SCIP_STATUS_RESTARTLIMIT: # <<<<<<<<<<<<<< + * return "restartlimit" + * elif stat == SCIP_STATUS_PRIMALLIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4997 + * elif stat == SCIP_STATUS_RESTARTLIMIT: + * return "restartlimit" + * elif stat == SCIP_STATUS_PRIMALLIMIT: # <<<<<<<<<<<<<< + * return "primallimit" + * elif stat == SCIP_STATUS_DUALLIMIT: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_PRIMALLIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":4998 + * return "restartlimit" + * elif stat == SCIP_STATUS_PRIMALLIMIT: + * return "primallimit" # <<<<<<<<<<<<<< + * elif stat == SCIP_STATUS_DUALLIMIT: + * return "duallimit" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_primallimit); + __pyx_r = __pyx_n_u_primallimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4997 + * elif stat == SCIP_STATUS_RESTARTLIMIT: + * return "restartlimit" + * elif stat == SCIP_STATUS_PRIMALLIMIT: # <<<<<<<<<<<<<< + * return "primallimit" + * elif stat == SCIP_STATUS_DUALLIMIT: + */ + } + + /* "src/pyscipopt/scip.pxi":4999 + * elif stat == SCIP_STATUS_PRIMALLIMIT: + * return "primallimit" + * elif stat == SCIP_STATUS_DUALLIMIT: # <<<<<<<<<<<<<< + * return "duallimit" + * else: + */ + __pyx_t_1 = (__pyx_v_stat == SCIP_STATUS_DUALLIMIT); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":5000 + * return "primallimit" + * elif stat == SCIP_STATUS_DUALLIMIT: + * return "duallimit" # <<<<<<<<<<<<<< + * else: + * return "unknown" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_duallimit); + __pyx_r = __pyx_n_u_duallimit; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":4999 + * elif stat == SCIP_STATUS_PRIMALLIMIT: + * return "primallimit" + * elif stat == SCIP_STATUS_DUALLIMIT: # <<<<<<<<<<<<<< + * return "duallimit" + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":5002 + * return "duallimit" + * else: + * return "unknown" # <<<<<<<<<<<<<< + * + * def getObjectiveSense(self): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_unknown); + __pyx_r = __pyx_n_u_unknown; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":4966 + * StageNames[attr] = name + * + * def getStatus(self): # <<<<<<<<<<<<<< + * """Retrieve solution status.""" + * cdef SCIP_STATUS stat = SCIPgetStatus(self._scip) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5004 + * return "unknown" + * + * def getObjectiveSense(self): # <<<<<<<<<<<<<< + * """Retrieve objective sense.""" + * cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_595getObjectiveSense(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_594getObjectiveSense, "Model.getObjectiveSense(self)\nRetrieve objective sense."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_595getObjectiveSense = {"getObjectiveSense", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_595getObjectiveSense, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_594getObjectiveSense}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_595getObjectiveSense(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getObjectiveSense (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getObjectiveSense", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getObjectiveSense", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_594getObjectiveSense(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_594getObjectiveSense(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_OBJSENSE __pyx_v_sense; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("getObjectiveSense", 1); + + /* "src/pyscipopt/scip.pxi":5006 + * def getObjectiveSense(self): + * """Retrieve objective sense.""" + * cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip) # <<<<<<<<<<<<<< + * if sense == SCIP_OBJSENSE_MAXIMIZE: + * return "maximize" + */ + __pyx_v_sense = SCIPgetObjsense(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":5007 + * """Retrieve objective sense.""" + * cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip) + * if sense == SCIP_OBJSENSE_MAXIMIZE: # <<<<<<<<<<<<<< + * return "maximize" + * elif sense == SCIP_OBJSENSE_MINIMIZE: + */ + __pyx_t_1 = (__pyx_v_sense == SCIP_OBJSENSE_MAXIMIZE); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":5008 + * cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip) + * if sense == SCIP_OBJSENSE_MAXIMIZE: + * return "maximize" # <<<<<<<<<<<<<< + * elif sense == SCIP_OBJSENSE_MINIMIZE: + * return "minimize" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_maximize); + __pyx_r = __pyx_n_u_maximize; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5007 + * """Retrieve objective sense.""" + * cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip) + * if sense == SCIP_OBJSENSE_MAXIMIZE: # <<<<<<<<<<<<<< + * return "maximize" + * elif sense == SCIP_OBJSENSE_MINIMIZE: + */ + } + + /* "src/pyscipopt/scip.pxi":5009 + * if sense == SCIP_OBJSENSE_MAXIMIZE: + * return "maximize" + * elif sense == SCIP_OBJSENSE_MINIMIZE: # <<<<<<<<<<<<<< + * return "minimize" + * else: + */ + __pyx_t_1 = (__pyx_v_sense == SCIP_OBJSENSE_MINIMIZE); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":5010 + * return "maximize" + * elif sense == SCIP_OBJSENSE_MINIMIZE: + * return "minimize" # <<<<<<<<<<<<<< + * else: + * return "unknown" + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_minimize); + __pyx_r = __pyx_n_u_minimize; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5009 + * if sense == SCIP_OBJSENSE_MAXIMIZE: + * return "maximize" + * elif sense == SCIP_OBJSENSE_MINIMIZE: # <<<<<<<<<<<<<< + * return "minimize" + * else: + */ + } + + /* "src/pyscipopt/scip.pxi":5012 + * return "minimize" + * else: + * return "unknown" # <<<<<<<<<<<<<< + * + * def catchEvent(self, eventtype, Eventhdlr eventhdlr): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_n_u_unknown); + __pyx_r = __pyx_n_u_unknown; + goto __pyx_L0; + } + + /* "src/pyscipopt/scip.pxi":5004 + * return "unknown" + * + * def getObjectiveSense(self): # <<<<<<<<<<<<<< + * """Retrieve objective sense.""" + * cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip) + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5014 + * return "unknown" + * + * def catchEvent(self, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches a global (not variable or row dependent) event""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_597catchEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_596catchEvent, "Model.catchEvent(self, eventtype, Eventhdlr eventhdlr)\ncatches a global (not variable or row dependent) event"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_597catchEvent = {"catchEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_597catchEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_596catchEvent}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_597catchEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_eventtype = 0; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("catchEvent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eventtype,&__pyx_n_s_eventhdlr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventtype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5014, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventhdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5014, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("catchEvent", 1, 2, 2, 1); __PYX_ERR(0, 5014, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "catchEvent") < 0)) __PYX_ERR(0, 5014, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_eventtype = values[0]; + __pyx_v_eventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("catchEvent", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5014, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.catchEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr, 1, "eventhdlr", 0))) __PYX_ERR(0, 5014, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_596catchEvent(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_eventtype, __pyx_v_eventhdlr); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_596catchEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr) { + SCIP_EVENTHDLR *__pyx_v__eventhdlr; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + SCIP_EVENTTYPE __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("catchEvent", 1); + + /* "src/pyscipopt/scip.pxi":5017 + * """catches a global (not variable or row dependent) event""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5018 + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) # <<<<<<<<<<<<<< + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_eventhdlr->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5019 + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) # <<<<<<<<<<<<<< + * else: + * raise Warning("event handler not found") + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5019, __pyx_L1_error) + __pyx_v__eventhdlr = SCIPfindEventhdlr(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":5017 + * """catches a global (not variable or row dependent) event""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5021 + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + * raise Warning("event handler not found") # <<<<<<<<<<<<<< + * + * Py_INCREF(self) + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5021, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5023 + * raise Warning("event handler not found") + * + * Py_INCREF(self) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcatchEvent(self._scip, eventtype, _eventhdlr, NULL, NULL)) + * + */ + Py_INCREF(((PyObject *)__pyx_v_self)); + + /* "src/pyscipopt/scip.pxi":5024 + * + * Py_INCREF(self) + * PY_SCIP_CALL(SCIPcatchEvent(self._scip, eventtype, _eventhdlr, NULL, NULL)) # <<<<<<<<<<<<<< + * + * def dropEvent(self, eventtype, Eventhdlr eventhdlr): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_As_SCIP_EVENTTYPE(__pyx_v_eventtype); if (unlikely((__pyx_t_7 == ((SCIP_EVENTTYPE)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5024, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcatchEvent(__pyx_v_self->_scip, __pyx_t_7, __pyx_v__eventhdlr, NULL, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5024, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5014 + * return "unknown" + * + * def catchEvent(self, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches a global (not variable or row dependent) event""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.catchEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5026 + * PY_SCIP_CALL(SCIPcatchEvent(self._scip, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropEvent(self, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops a global event (stops to track event)""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_599dropEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_598dropEvent, "Model.dropEvent(self, eventtype, Eventhdlr eventhdlr)\ndrops a global event (stops to track event)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_599dropEvent = {"dropEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_599dropEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_598dropEvent}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_599dropEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_eventtype = 0; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("dropEvent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_eventtype,&__pyx_n_s_eventhdlr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventtype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5026, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventhdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5026, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("dropEvent", 1, 2, 2, 1); __PYX_ERR(0, 5026, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "dropEvent") < 0)) __PYX_ERR(0, 5026, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_eventtype = values[0]; + __pyx_v_eventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("dropEvent", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5026, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.dropEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr, 1, "eventhdlr", 0))) __PYX_ERR(0, 5026, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_598dropEvent(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_eventtype, __pyx_v_eventhdlr); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_598dropEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr) { + SCIP_EVENTHDLR *__pyx_v__eventhdlr; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + SCIP_EVENTTYPE __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dropEvent", 1); + + /* "src/pyscipopt/scip.pxi":5029 + * """drops a global event (stops to track event)""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5030 + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) # <<<<<<<<<<<<<< + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_eventhdlr->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5031 + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) # <<<<<<<<<<<<<< + * else: + * raise Warning("event handler not found") + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5031, __pyx_L1_error) + __pyx_v__eventhdlr = SCIPfindEventhdlr(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":5029 + * """drops a global event (stops to track event)""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5033 + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + * raise Warning("event handler not found") # <<<<<<<<<<<<<< + * + * Py_DECREF(self) + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5033, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5033, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5035 + * raise Warning("event handler not found") + * + * Py_DECREF(self) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPdropEvent(self._scip, eventtype, _eventhdlr, NULL, -1)) + * + */ + Py_DECREF(((PyObject *)__pyx_v_self)); + + /* "src/pyscipopt/scip.pxi":5036 + * + * Py_DECREF(self) + * PY_SCIP_CALL(SCIPdropEvent(self._scip, eventtype, _eventhdlr, NULL, -1)) # <<<<<<<<<<<<<< + * + * def catchVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5036, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_As_SCIP_EVENTTYPE(__pyx_v_eventtype); if (unlikely((__pyx_t_7 == ((SCIP_EVENTTYPE)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5036, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPdropEvent(__pyx_v_self->_scip, __pyx_t_7, __pyx_v__eventhdlr, NULL, -1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5036, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5036, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5026 + * PY_SCIP_CALL(SCIPcatchEvent(self._scip, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropEvent(self, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops a global event (stops to track event)""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.dropEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5038 + * PY_SCIP_CALL(SCIPdropEvent(self._scip, eventtype, _eventhdlr, NULL, -1)) + * + * def catchVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches an objective value or domain change event on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_601catchVarEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_600catchVarEvent, "Model.catchVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr)\ncatches an objective value or domain change event on the given transformed variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_601catchVarEvent = {"catchVarEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_601catchVarEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_600catchVarEvent}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_601catchVarEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_eventtype = 0; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("catchVarEvent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_eventtype,&__pyx_n_s_eventhdlr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5038, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventtype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5038, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("catchVarEvent", 1, 3, 3, 1); __PYX_ERR(0, 5038, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventhdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5038, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("catchVarEvent", 1, 3, 3, 2); __PYX_ERR(0, 5038, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "catchVarEvent") < 0)) __PYX_ERR(0, 5038, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_eventtype = values[1]; + __pyx_v_eventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("catchVarEvent", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 5038, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.catchVarEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 5038, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr, 1, "eventhdlr", 0))) __PYX_ERR(0, 5038, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_600catchVarEvent(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_eventtype, __pyx_v_eventhdlr); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_600catchVarEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr) { + SCIP_EVENTHDLR *__pyx_v__eventhdlr; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + SCIP_EVENTTYPE __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("catchVarEvent", 1); + + /* "src/pyscipopt/scip.pxi":5041 + * """catches an objective value or domain change event on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5042 + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) # <<<<<<<<<<<<<< + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5042, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_eventhdlr->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5042, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5043 + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) # <<<<<<<<<<<<<< + * else: + * raise Warning("event handler not found") + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5043, __pyx_L1_error) + __pyx_v__eventhdlr = SCIPfindEventhdlr(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":5041 + * """catches an objective value or domain change event on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5045 + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + * raise Warning("event handler not found") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcatchVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, NULL)) + * + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5045, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5046 + * else: + * raise Warning("event handler not found") + * PY_SCIP_CALL(SCIPcatchVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, NULL)) # <<<<<<<<<<<<<< + * + * def dropVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_As_SCIP_EVENTTYPE(__pyx_v_eventtype); if (unlikely((__pyx_t_7 == ((SCIP_EVENTTYPE)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5046, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcatchVarEvent(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_7, __pyx_v__eventhdlr, NULL, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5038 + * PY_SCIP_CALL(SCIPdropEvent(self._scip, eventtype, _eventhdlr, NULL, -1)) + * + * def catchVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches an objective value or domain change event on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.catchVarEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5048 + * PY_SCIP_CALL(SCIPcatchVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops an objective value or domain change event (stops to track event) on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_603dropVarEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_602dropVarEvent, "Model.dropVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr)\ndrops an objective value or domain change event (stops to track event) on the given transformed variable"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_603dropVarEvent = {"dropVarEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_603dropVarEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_602dropVarEvent}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_603dropVarEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_eventtype = 0; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("dropVarEvent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_eventtype,&__pyx_n_s_eventhdlr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5048, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventtype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5048, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("dropVarEvent", 1, 3, 3, 1); __PYX_ERR(0, 5048, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventhdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5048, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("dropVarEvent", 1, 3, 3, 2); __PYX_ERR(0, 5048, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "dropVarEvent") < 0)) __PYX_ERR(0, 5048, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_eventtype = values[1]; + __pyx_v_eventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("dropVarEvent", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 5048, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.dropVarEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 5048, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr, 1, "eventhdlr", 0))) __PYX_ERR(0, 5048, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_602dropVarEvent(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_eventtype, __pyx_v_eventhdlr); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_602dropVarEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr) { + SCIP_EVENTHDLR *__pyx_v__eventhdlr; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + SCIP_EVENTTYPE __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dropVarEvent", 1); + + /* "src/pyscipopt/scip.pxi":5051 + * """drops an objective value or domain change event (stops to track event) on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5052 + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) # <<<<<<<<<<<<<< + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5052, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_eventhdlr->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5052, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5053 + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) # <<<<<<<<<<<<<< + * else: + * raise Warning("event handler not found") + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5053, __pyx_L1_error) + __pyx_v__eventhdlr = SCIPfindEventhdlr(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":5051 + * """drops an objective value or domain change event (stops to track event) on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5055 + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + * raise Warning("event handler not found") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPdropVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, -1)) + * + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5055, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5055, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5056 + * else: + * raise Warning("event handler not found") + * PY_SCIP_CALL(SCIPdropVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, -1)) # <<<<<<<<<<<<<< + * + * def catchRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_As_SCIP_EVENTTYPE(__pyx_v_eventtype); if (unlikely((__pyx_t_7 == ((SCIP_EVENTTYPE)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5056, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPdropVarEvent(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_7, __pyx_v__eventhdlr, NULL, -1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5048 + * PY_SCIP_CALL(SCIPcatchVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops an objective value or domain change event (stops to track event) on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.dropVarEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5058 + * PY_SCIP_CALL(SCIPdropVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, -1)) + * + * def catchRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches a row coefficient, constant, or side change event on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_605catchRowEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_604catchRowEvent, "Model.catchRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr)\ncatches a row coefficient, constant, or side change event on the given row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_605catchRowEvent = {"catchRowEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_605catchRowEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_604catchRowEvent}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_605catchRowEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + PyObject *__pyx_v_eventtype = 0; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("catchRowEvent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_eventtype,&__pyx_n_s_eventhdlr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5058, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventtype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5058, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("catchRowEvent", 1, 3, 3, 1); __PYX_ERR(0, 5058, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventhdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5058, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("catchRowEvent", 1, 3, 3, 2); __PYX_ERR(0, 5058, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "catchRowEvent") < 0)) __PYX_ERR(0, 5058, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_eventtype = values[1]; + __pyx_v_eventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("catchRowEvent", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 5058, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.catchRowEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 5058, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr, 1, "eventhdlr", 0))) __PYX_ERR(0, 5058, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_604catchRowEvent(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row, __pyx_v_eventtype, __pyx_v_eventhdlr); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_604catchRowEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr) { + SCIP_EVENTHDLR *__pyx_v__eventhdlr; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + SCIP_EVENTTYPE __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("catchRowEvent", 1); + + /* "src/pyscipopt/scip.pxi":5061 + * """catches a row coefficient, constant, or side change event on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5062 + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) # <<<<<<<<<<<<<< + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_eventhdlr->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5063 + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) # <<<<<<<<<<<<<< + * else: + * raise Warning("event handler not found") + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5063, __pyx_L1_error) + __pyx_v__eventhdlr = SCIPfindEventhdlr(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":5061 + * """catches a row coefficient, constant, or side change event on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5065 + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + * raise Warning("event handler not found") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPcatchRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, NULL)) + * + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5065, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5065, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5066 + * else: + * raise Warning("event handler not found") + * PY_SCIP_CALL(SCIPcatchRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, NULL)) # <<<<<<<<<<<<<< + * + * def dropRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5066, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_As_SCIP_EVENTTYPE(__pyx_v_eventtype); if (unlikely((__pyx_t_7 == ((SCIP_EVENTTYPE)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5066, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcatchRowEvent(__pyx_v_self->_scip, __pyx_v_row->scip_row, __pyx_t_7, __pyx_v__eventhdlr, NULL, NULL)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5066, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5066, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5058 + * PY_SCIP_CALL(SCIPdropVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, -1)) + * + * def catchRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches a row coefficient, constant, or side change event on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.catchRowEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5068 + * PY_SCIP_CALL(SCIPcatchRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops a row coefficient, constant, or side change event (stops to track event) on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_607dropRowEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_606dropRowEvent, "Model.dropRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr)\ndrops a row coefficient, constant, or side change event (stops to track event) on the given row"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_607dropRowEvent = {"dropRowEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_607dropRowEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_606dropRowEvent}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_607dropRowEvent(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row = 0; + PyObject *__pyx_v_eventtype = 0; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("dropRowEvent (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_eventtype,&__pyx_n_s_eventhdlr,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_row)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5068, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventtype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5068, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("dropRowEvent", 1, 3, 3, 1); __PYX_ERR(0, 5068, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_eventhdlr)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5068, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("dropRowEvent", 1, 3, 3, 2); __PYX_ERR(0, 5068, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "dropRowEvent") < 0)) __PYX_ERR(0, 5068, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v_row = ((struct __pyx_obj_9pyscipopt_4scip_Row *)values[0]); + __pyx_v_eventtype = values[1]; + __pyx_v_eventhdlr = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("dropRowEvent", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 5068, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.dropRowEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_row), __pyx_ptype_9pyscipopt_4scip_Row, 1, "row", 0))) __PYX_ERR(0, 5068, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr, 1, "eventhdlr", 0))) __PYX_ERR(0, 5068, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_606dropRowEvent(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_row, __pyx_v_eventtype, __pyx_v_eventhdlr); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_606dropRowEvent(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Row *__pyx_v_row, PyObject *__pyx_v_eventtype, struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v_eventhdlr) { + SCIP_EVENTHDLR *__pyx_v__eventhdlr; + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + SCIP_EVENTTYPE __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("dropRowEvent", 1); + + /* "src/pyscipopt/scip.pxi":5071 + * """drops a row coefficient, constant, or side change event (stops to track event) on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_eventhdlr), __pyx_ptype_9pyscipopt_4scip_Eventhdlr); + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5072 + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) # <<<<<<<<<<<<<< + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5072, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_eventhdlr->name}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5072, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_n = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5073 + * if isinstance(eventhdlr, Eventhdlr): + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) # <<<<<<<<<<<<<< + * else: + * raise Warning("event handler not found") + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5073, __pyx_L1_error) + __pyx_v__eventhdlr = SCIPfindEventhdlr(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":5071 + * """drops a row coefficient, constant, or side change event (stops to track event) on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + * if isinstance(eventhdlr, Eventhdlr): # <<<<<<<<<<<<<< + * n = str_conversion(eventhdlr.name) + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5075 + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + * raise Warning("event handler not found") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPdropRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, -1)) + * + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_Warning, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5075, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5075, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5076 + * else: + * raise Warning("event handler not found") + * PY_SCIP_CALL(SCIPdropRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, -1)) # <<<<<<<<<<<<<< + * + * # Statistic Methods + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_As_SCIP_EVENTTYPE(__pyx_v_eventtype); if (unlikely((__pyx_t_7 == ((SCIP_EVENTTYPE)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5076, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPdropRowEvent(__pyx_v_self->_scip, __pyx_v_row->scip_row, __pyx_t_7, __pyx_v__eventhdlr, NULL, -1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5068 + * PY_SCIP_CALL(SCIPcatchRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops a row coefficient, constant, or side change event (stops to track event) on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.dropRowEvent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5080 + * # Statistic Methods + * + * def printStatistics(self): # <<<<<<<<<<<<<< + * """Print statistics.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_609printStatistics(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_608printStatistics, "Model.printStatistics(self)\nPrint statistics."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_609printStatistics = {"printStatistics", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_609printStatistics, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_608printStatistics}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_609printStatistics(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("printStatistics (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("printStatistics", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "printStatistics", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_608printStatistics(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_608printStatistics(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("printStatistics", 1); + + /* "src/pyscipopt/scip.pxi":5082 + * def printStatistics(self): + * """Print statistics.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5082, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5082, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5082, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5082, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5082, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 5082, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5082, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5083 + * """Print statistics.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPprintStatistics(self._scip, NULL)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5085 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * PY_SCIP_CALL(SCIPprintStatistics(self._scip, NULL)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5085, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintStatistics(__pyx_v_self->_scip, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5085, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5085, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5087 + * PY_SCIP_CALL(SCIPprintStatistics(self._scip, NULL)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def writeStatistics(self, filename="origprob.stats"): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5087, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5087, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5087, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5087, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5087, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5080 + * # Statistic Methods + * + * def printStatistics(self): # <<<<<<<<<<<<<< + * """Print statistics.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.printStatistics", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5089 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeStatistics(self, filename="origprob.stats"): # <<<<<<<<<<<<<< + * """Write statistics to a file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_611writeStatistics(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_610writeStatistics, "Model.writeStatistics(self, filename=u'origprob.stats')\nWrite statistics to a file.\n\n Keyword arguments:\n filename -- name of the output file\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_611writeStatistics = {"writeStatistics", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_611writeStatistics, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_610writeStatistics}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_611writeStatistics(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeStatistics (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_origprob_stats)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5089, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeStatistics") < 0)) __PYX_ERR(0, 5089, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeStatistics", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 5089, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeStatistics", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_610writeStatistics(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_610writeStatistics(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_f = NULL; + FILE *__pyx_v_cfile; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeStatistics", 1); + + /* "src/pyscipopt/scip.pxi":5095 + * filename -- name of the output file + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 5095, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5095, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5096 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * # use this doubled opening pattern to ensure that IOErrors are + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5100 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintStatistics(self._scip, cfile)) + */ + /*with:*/ { + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_filename); + __Pyx_GIVEREF(__pyx_v_filename); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_filename)) __PYX_ERR(0, 5100, __pyx_L1_error); + __Pyx_INCREF(__pyx_n_u_w); + __Pyx_GIVEREF(__pyx_n_u_w); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_n_u_w)) __PYX_ERR(0, 5100, __pyx_L1_error); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_exit); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_enter); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5100, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5100, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + /*try:*/ { + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + /*try:*/ { + __pyx_v_f = __pyx_t_3; + __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":5101 + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPprintStatistics(self._scip, cfile)) + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_f, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5101, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5101, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 5101, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_cfile = fdopen(__pyx_t_5, ((char const *)"w")); + + /* "src/pyscipopt/scip.pxi":5102 + * with open(filename, "w") as f: + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintStatistics(self._scip, cfile)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5102, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPprintStatistics(__pyx_v_self->_scip, __pyx_v_cfile)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5102, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5102, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":5100 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintStatistics(self._scip, cfile)) + */ + } + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L12_try_end; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + /*except:*/ { + __Pyx_AddTraceback("pyscipopt.scip.Model.writeStatistics", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 5100, __pyx_L9_except_error) + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_Pack(3, __pyx_t_3, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5100, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5100, __pyx_L9_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_10); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (__pyx_t_11 < 0) __PYX_ERR(0, 5100, __pyx_L9_except_error) + __pyx_t_12 = (!__pyx_t_11); + if (unlikely(__pyx_t_12)) { + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ErrRestoreWithState(__pyx_t_3, __pyx_t_2, __pyx_t_4); + __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_4 = 0; + __PYX_ERR(0, 5100, __pyx_L9_except_error) + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L8_exception_handled; + } + __pyx_L9_except_error:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + goto __pyx_L1_error; + __pyx_L8_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_L12_try_end:; + } + } + /*finally:*/ { + /*normal exit:*/{ + if (__pyx_t_6) { + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__107, NULL); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5100, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + goto __pyx_L6; + } + __pyx_L6:; + } + goto __pyx_L16; + __pyx_L3_error:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L1_error; + __pyx_L16:; + } + + /* "src/pyscipopt/scip.pxi":5104 + * PY_SCIP_CALL(SCIPprintStatistics(self._scip, cfile)) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def getNLPs(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5089 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeStatistics(self, filename="origprob.stats"): # <<<<<<<<<<<<<< + * """Write statistics to a file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeStatistics", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_f); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5106 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getNLPs(self): # <<<<<<<<<<<<<< + * """gets total number of LPs solved so far""" + * return SCIPgetNLPs(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_613getNLPs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_612getNLPs, "Model.getNLPs(self)\ngets total number of LPs solved so far"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_613getNLPs = {"getNLPs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_613getNLPs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_612getNLPs}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_613getNLPs(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNLPs (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNLPs", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNLPs", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_612getNLPs(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_612getNLPs(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNLPs", 1); + + /* "src/pyscipopt/scip.pxi":5108 + * def getNLPs(self): + * """gets total number of LPs solved so far""" + * return SCIPgetNLPs(self._scip) # <<<<<<<<<<<<<< + * + * # Verbosity Methods + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPgetNLPs(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5106 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getNLPs(self): # <<<<<<<<<<<<<< + * """gets total number of LPs solved so far""" + * return SCIPgetNLPs(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNLPs", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5112 + * # Verbosity Methods + * + * def hideOutput(self, quiet = True): # <<<<<<<<<<<<<< + * """Hide the output. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_615hideOutput(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_614hideOutput, "Model.hideOutput(self, quiet=True)\nHide the output.\n\n :param quiet: hide output? (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_615hideOutput = {"hideOutput", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_615hideOutput, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_614hideOutput}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_615hideOutput(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_quiet = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("hideOutput (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_quiet,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_quiet); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5112, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "hideOutput") < 0)) __PYX_ERR(0, 5112, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_quiet = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("hideOutput", 0, 0, 1, __pyx_nargs); __PYX_ERR(0, 5112, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.hideOutput", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_614hideOutput(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_quiet); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_614hideOutput(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_quiet) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + SCIP_Bool __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("hideOutput", 1); + + /* "src/pyscipopt/scip.pxi":5118 + * + * """ + * SCIPsetMessagehdlrQuiet(self._scip, quiet) # <<<<<<<<<<<<<< + * + * # Output Methods + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_quiet); if (unlikely((__pyx_t_1 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5118, __pyx_L1_error) + SCIPsetMessagehdlrQuiet(__pyx_v_self->_scip, __pyx_t_1); + + /* "src/pyscipopt/scip.pxi":5112 + * # Verbosity Methods + * + * def hideOutput(self, quiet = True): # <<<<<<<<<<<<<< + * """Hide the output. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Model.hideOutput", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5122 + * # Output Methods + * + * def redirectOutput(self): # <<<<<<<<<<<<<< + * """Send output to python instead of terminal.""" + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_617redirectOutput(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_616redirectOutput, "Model.redirectOutput(self)\nSend output to python instead of terminal."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_617redirectOutput = {"redirectOutput", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_617redirectOutput, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_616redirectOutput}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_617redirectOutput(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("redirectOutput (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("redirectOutput", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "redirectOutput", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_616redirectOutput(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_616redirectOutput(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_MESSAGEHDLR *__pyx_v_myMessageHandler; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("redirectOutput", 1); + + /* "src/pyscipopt/scip.pxi":5127 + * cdef SCIP_MESSAGEHDLR *myMessageHandler + * + * PY_SCIP_CALL(SCIPmessagehdlrCreate(&myMessageHandler, False, NULL, False, relayMessage, relayMessage, relayMessage, NULL, NULL)) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetMessagehdlr(self._scip, myMessageHandler)) + * SCIPmessageSetErrorPrinting(relayErrorMessage, NULL) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPmessagehdlrCreate((&__pyx_v_myMessageHandler), 0, NULL, 0, __pyx_f_9pyscipopt_4scip_relayMessage, __pyx_f_9pyscipopt_4scip_relayMessage, __pyx_f_9pyscipopt_4scip_relayMessage, NULL, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5128 + * + * PY_SCIP_CALL(SCIPmessagehdlrCreate(&myMessageHandler, False, NULL, False, relayMessage, relayMessage, relayMessage, NULL, NULL)) + * PY_SCIP_CALL(SCIPsetMessagehdlr(self._scip, myMessageHandler)) # <<<<<<<<<<<<<< + * SCIPmessageSetErrorPrinting(relayErrorMessage, NULL) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetMessagehdlr(__pyx_v_self->_scip, __pyx_v_myMessageHandler)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5129 + * PY_SCIP_CALL(SCIPmessagehdlrCreate(&myMessageHandler, False, NULL, False, relayMessage, relayMessage, relayMessage, NULL, NULL)) + * PY_SCIP_CALL(SCIPsetMessagehdlr(self._scip, myMessageHandler)) + * SCIPmessageSetErrorPrinting(relayErrorMessage, NULL) # <<<<<<<<<<<<<< + * + * def setLogfile(self, path): + */ + SCIPmessageSetErrorPrinting(__pyx_f_9pyscipopt_4scip_relayErrorMessage, NULL); + + /* "src/pyscipopt/scip.pxi":5122 + * # Output Methods + * + * def redirectOutput(self): # <<<<<<<<<<<<<< + * """Send output to python instead of terminal.""" + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.redirectOutput", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5131 + * SCIPmessageSetErrorPrinting(relayErrorMessage, NULL) + * + * def setLogfile(self, path): # <<<<<<<<<<<<<< + * """sets the log file name for the currently installed message handler + * :param path: name of log file, or None (no log) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_619setLogfile(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_618setLogfile, "Model.setLogfile(self, path)\nsets the log file name for the currently installed message handler\n :param path: name of log file, or None (no log)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_619setLogfile = {"setLogfile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_619setLogfile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_618setLogfile}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_619setLogfile(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_path = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setLogfile (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_path)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5131, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setLogfile") < 0)) __PYX_ERR(0, 5131, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_path = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setLogfile", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5131, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setLogfile", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_618setLogfile(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_path); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_618setLogfile(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_path) { + PyObject *__pyx_v_c_path = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char const *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setLogfile", 1); + + /* "src/pyscipopt/scip.pxi":5135 + * :param path: name of log file, or None (no log) + * """ + * if path: # <<<<<<<<<<<<<< + * c_path = str_conversion(path) + * SCIPsetMessagehdlrLogfile(self._scip, c_path) + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_path); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 5135, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":5136 + * """ + * if path: + * c_path = str_conversion(path) # <<<<<<<<<<<<<< + * SCIPsetMessagehdlrLogfile(self._scip, c_path) + * else: + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_path}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v_c_path = __pyx_t_2; + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5137 + * if path: + * c_path = str_conversion(path) + * SCIPsetMessagehdlrLogfile(self._scip, c_path) # <<<<<<<<<<<<<< + * else: + * SCIPsetMessagehdlrLogfile(self._scip, NULL) + */ + __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_c_path); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5137, __pyx_L1_error) + SCIPsetMessagehdlrLogfile(__pyx_v_self->_scip, __pyx_t_6); + + /* "src/pyscipopt/scip.pxi":5135 + * :param path: name of log file, or None (no log) + * """ + * if path: # <<<<<<<<<<<<<< + * c_path = str_conversion(path) + * SCIPsetMessagehdlrLogfile(self._scip, c_path) + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5139 + * SCIPsetMessagehdlrLogfile(self._scip, c_path) + * else: + * SCIPsetMessagehdlrLogfile(self._scip, NULL) # <<<<<<<<<<<<<< + * + * # Parameter Methods + */ + /*else*/ { + SCIPsetMessagehdlrLogfile(__pyx_v_self->_scip, NULL); + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5131 + * SCIPmessageSetErrorPrinting(relayErrorMessage, NULL) + * + * def setLogfile(self, path): # <<<<<<<<<<<<<< + * """sets the log file name for the currently installed message handler + * :param path: name of log file, or None (no log) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.setLogfile", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_c_path); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5143 + * # Parameter Methods + * + * def setBoolParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a boolean-valued parameter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_621setBoolParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_620setBoolParam, "Model.setBoolParam(self, name, value)\nSet a boolean-valued parameter.\n\n :param name: name of parameter\n :param value: value of parameter\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_621setBoolParam = {"setBoolParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_621setBoolParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_620setBoolParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_621setBoolParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setBoolParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5143, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5143, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setBoolParam", 1, 2, 2, 1); __PYX_ERR(0, 5143, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setBoolParam") < 0)) __PYX_ERR(0, 5143, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_name = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setBoolParam", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5143, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setBoolParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_620setBoolParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_620setBoolParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char *__pyx_t_5; + SCIP_Bool __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setBoolParam", 1); + + /* "src/pyscipopt/scip.pxi":5150 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, value)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5150, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5151 + * """ + * n = str_conversion(name) + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, value)) # <<<<<<<<<<<<<< + * + * def setIntParam(self, name, value): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5151, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_6 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5151, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetBoolParam(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5151, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5143 + * # Parameter Methods + * + * def setBoolParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a boolean-valued parameter. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.setBoolParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5153 + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, value)) + * + * def setIntParam(self, name, value): # <<<<<<<<<<<<<< + * """Set an int-valued parameter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_623setIntParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_622setIntParam, "Model.setIntParam(self, name, value)\nSet an int-valued parameter.\n\n :param name: name of parameter\n :param value: value of parameter\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_623setIntParam = {"setIntParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_623setIntParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_622setIntParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_623setIntParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setIntParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5153, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5153, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setIntParam", 1, 2, 2, 1); __PYX_ERR(0, 5153, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setIntParam") < 0)) __PYX_ERR(0, 5153, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_name = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setIntParam", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5153, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setIntParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_622setIntParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_622setIntParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setIntParam", 1); + + /* "src/pyscipopt/scip.pxi":5160 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, value)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5160, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5161 + * """ + * n = str_conversion(name) + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, value)) # <<<<<<<<<<<<<< + * + * def setLongintParam(self, name, value): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5161, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 5161, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetIntParam(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5153 + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, value)) + * + * def setIntParam(self, name, value): # <<<<<<<<<<<<<< + * """Set an int-valued parameter. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.setIntParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5163 + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, value)) + * + * def setLongintParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a long-valued parameter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_625setLongintParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_624setLongintParam, "Model.setLongintParam(self, name, value)\nSet a long-valued parameter.\n\n :param name: name of parameter\n :param value: value of parameter\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_625setLongintParam = {"setLongintParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_625setLongintParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_624setLongintParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_625setLongintParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setLongintParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5163, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5163, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setLongintParam", 1, 2, 2, 1); __PYX_ERR(0, 5163, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setLongintParam") < 0)) __PYX_ERR(0, 5163, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_name = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setLongintParam", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5163, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setLongintParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_624setLongintParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_624setLongintParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char *__pyx_t_5; + SCIP_Longint __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setLongintParam", 1); + + /* "src/pyscipopt/scip.pxi":5170 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, value)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5171 + * """ + * n = str_conversion(name) + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, value)) # <<<<<<<<<<<<<< + * + * def setRealParam(self, name, value): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5171, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_SCIP_Longint(__pyx_v_value); if (unlikely((__pyx_t_6 == ((SCIP_Longint)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5171, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetLongintParam(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5171, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5163 + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, value)) + * + * def setLongintParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a long-valued parameter. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.setLongintParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5173 + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, value)) + * + * def setRealParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a real-valued parameter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_627setRealParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_626setRealParam, "Model.setRealParam(self, name, value)\nSet a real-valued parameter.\n\n :param name: name of parameter\n :param value: value of parameter\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_627setRealParam = {"setRealParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_627setRealParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_626setRealParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_627setRealParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setRealParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5173, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5173, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setRealParam", 1, 2, 2, 1); __PYX_ERR(0, 5173, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setRealParam") < 0)) __PYX_ERR(0, 5173, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_name = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setRealParam", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5173, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setRealParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_626setRealParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_626setRealParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char *__pyx_t_5; + SCIP_Real __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setRealParam", 1); + + /* "src/pyscipopt/scip.pxi":5180 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, value)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5181 + * """ + * n = str_conversion(name) + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, value)) # <<<<<<<<<<<<<< + * + * def setCharParam(self, name, value): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5181, __pyx_L1_error) + __pyx_t_6 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_6 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5181, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetRealParam(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5173 + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, value)) + * + * def setRealParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a real-valued parameter. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.setRealParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5183 + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, value)) + * + * def setCharParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a char-valued parameter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_629setCharParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_628setCharParam, "Model.setCharParam(self, name, value)\nSet a char-valued parameter.\n\n :param name: name of parameter\n :param value: value of parameter\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_629setCharParam = {"setCharParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_629setCharParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_628setCharParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_629setCharParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setCharParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5183, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5183, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setCharParam", 1, 2, 2, 1); __PYX_ERR(0, 5183, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setCharParam") < 0)) __PYX_ERR(0, 5183, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_name = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setCharParam", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5183, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setCharParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_628setCharParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_628setCharParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char *__pyx_t_5; + long __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setCharParam", 1); + + /* "src/pyscipopt/scip.pxi":5190 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5191 + * """ + * n = str_conversion(name) + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) # <<<<<<<<<<<<<< + * + * def setStringParam(self, name, value): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5191, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Ord(__pyx_v_value); if (unlikely(__pyx_t_6 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 5191, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetCharParam(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5191, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5183 + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, value)) + * + * def setCharParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a char-valued parameter. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.setCharParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5193 + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * + * def setStringParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a string-valued parameter. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_631setStringParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_630setStringParam, "Model.setStringParam(self, name, value)\nSet a string-valued parameter.\n\n :param name: name of parameter\n :param value: value of parameter\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_631setStringParam = {"setStringParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_631setStringParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_630setStringParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_631setStringParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setStringParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5193, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5193, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setStringParam", 1, 2, 2, 1); __PYX_ERR(0, 5193, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setStringParam") < 0)) __PYX_ERR(0, 5193, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_name = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setStringParam", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5193, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setStringParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_630setStringParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_630setStringParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_v_v = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char *__pyx_t_5; + char *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setStringParam", 1); + + /* "src/pyscipopt/scip.pxi":5200 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * v = str_conversion(value) + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5200, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5201 + * """ + * n = str_conversion(name) + * v = str_conversion(value) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_value}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_v = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5202 + * n = str_conversion(name) + * v = str_conversion(value) + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) # <<<<<<<<<<<<<< + * + * def setParam(self, name, value): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5202, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_AsWritableString(__pyx_v_v); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5202, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetStringParam(__pyx_v_self->_scip, __pyx_t_5, __pyx_t_6)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5193 + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * + * def setStringParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a string-valued parameter. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.Model.setStringParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5204 + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) + * + * def setParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a parameter with value in int, bool, real, long, char or str. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_633setParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_632setParam, "Model.setParam(self, name, value)\nSet a parameter with value in int, bool, real, long, char or str.\n\n :param name: name of parameter\n :param value: value of parameter\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_633setParam = {"setParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_633setParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_632setParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_633setParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5204, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5204, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("setParam", 1, 2, 2, 1); __PYX_ERR(0, 5204, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setParam") < 0)) __PYX_ERR(0, 5204, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_name = values[0]; + __pyx_v_value = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setParam", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5204, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_632setParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name, __pyx_v_value); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_632setParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { + SCIP_PARAM *__pyx_v_param; + PyObject *__pyx_v_n = NULL; + SCIP_PARAMTYPE __pyx_v_paramtype; + PyObject *__pyx_v_v = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + int __pyx_t_6; + char *__pyx_t_7; + PyObject *__pyx_t_8 = NULL; + SCIP_Longint __pyx_t_9; + double __pyx_t_10; + long __pyx_t_11; + char *__pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setParam", 1); + + /* "src/pyscipopt/scip.pxi":5212 + * cdef SCIP_PARAM* param + * + * n = str_conversion(name) # <<<<<<<<<<<<<< + * param = SCIPgetParam(self._scip, n) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5213 + * + * n = str_conversion(name) + * param = SCIPgetParam(self._scip, n) # <<<<<<<<<<<<<< + * + * if param == NULL: + */ + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5213, __pyx_L1_error) + __pyx_v_param = SCIPgetParam(__pyx_v_self->_scip, __pyx_t_5); + + /* "src/pyscipopt/scip.pxi":5215 + * param = SCIPgetParam(self._scip, n) + * + * if param == NULL: # <<<<<<<<<<<<<< + * raise KeyError("Not a valid parameter name") + * + */ + __pyx_t_6 = (__pyx_v_param == NULL); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":5216 + * + * if param == NULL: + * raise KeyError("Not a valid parameter name") # <<<<<<<<<<<<<< + * + * paramtype = SCIPparamGetType(param) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__109, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 5216, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5215 + * param = SCIPgetParam(self._scip, n) + * + * if param == NULL: # <<<<<<<<<<<<<< + * raise KeyError("Not a valid parameter name") + * + */ + } + + /* "src/pyscipopt/scip.pxi":5218 + * raise KeyError("Not a valid parameter name") + * + * paramtype = SCIPparamGetType(param) # <<<<<<<<<<<<<< + * + * if paramtype == SCIP_PARAMTYPE_BOOL: + */ + __pyx_v_paramtype = SCIPparamGetType(__pyx_v_param); + + /* "src/pyscipopt/scip.pxi":5220 + * paramtype = SCIPparamGetType(param) + * + * if paramtype == SCIP_PARAMTYPE_BOOL: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, bool(int(value)))) + * elif paramtype == SCIP_PARAMTYPE_INT: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_BOOL); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5221 + * + * if paramtype == SCIP_PARAMTYPE_BOOL: + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, bool(int(value)))) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_INT: + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, int(value))) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 5221, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 5221, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetBoolParam(__pyx_v_self->_scip, __pyx_t_7, (!(!__pyx_t_6)))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5220 + * paramtype = SCIPparamGetType(param) + * + * if paramtype == SCIP_PARAMTYPE_BOOL: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, bool(int(value)))) + * elif paramtype == SCIP_PARAMTYPE_INT: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":5222 + * if paramtype == SCIP_PARAMTYPE_BOOL: + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, bool(int(value)))) + * elif paramtype == SCIP_PARAMTYPE_INT: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_INT); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5223 + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, bool(int(value)))) + * elif paramtype == SCIP_PARAMTYPE_INT: + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, int(value))) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, int(value))) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 5223, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 5223, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetIntParam(__pyx_v_self->_scip, __pyx_t_7, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5222 + * if paramtype == SCIP_PARAMTYPE_BOOL: + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, bool(int(value)))) + * elif paramtype == SCIP_PARAMTYPE_INT: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":5224 + * elif paramtype == SCIP_PARAMTYPE_INT: + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_REAL: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_LONGINT); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5225 + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, int(value))) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_REAL: + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, float(value))) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 5225, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyNumber_Int(__pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_9 = __Pyx_PyInt_As_SCIP_Longint(__pyx_t_3); if (unlikely((__pyx_t_9 == ((SCIP_Longint)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5225, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetLongintParam(__pyx_v_self->_scip, __pyx_t_7, __pyx_t_9)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5224 + * elif paramtype == SCIP_PARAMTYPE_INT: + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_REAL: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":5226 + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_REAL: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, float(value))) + * elif paramtype == SCIP_PARAMTYPE_CHAR: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_REAL); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5227 + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_REAL: + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, float(value))) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_CHAR: + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 5227, __pyx_L1_error) + __pyx_t_10 = __Pyx_PyObject_AsDouble(__pyx_v_value); if (unlikely(__pyx_t_10 == ((double)((double)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5227, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetRealParam(__pyx_v_self->_scip, __pyx_t_7, __pyx_t_10)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5226 + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, int(value))) + * elif paramtype == SCIP_PARAMTYPE_REAL: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, float(value))) + * elif paramtype == SCIP_PARAMTYPE_CHAR: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":5228 + * elif paramtype == SCIP_PARAMTYPE_REAL: + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, float(value))) + * elif paramtype == SCIP_PARAMTYPE_CHAR: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * elif paramtype == SCIP_PARAMTYPE_STRING: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_CHAR); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5229 + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, float(value))) + * elif paramtype == SCIP_PARAMTYPE_CHAR: + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_STRING: + * v = str_conversion(value) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 5229, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_Ord(__pyx_v_value); if (unlikely(__pyx_t_11 == ((long)(long)(Py_UCS4)-1))) __PYX_ERR(0, 5229, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetCharParam(__pyx_v_self->_scip, __pyx_t_7, __pyx_t_11)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5228 + * elif paramtype == SCIP_PARAMTYPE_REAL: + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, float(value))) + * elif paramtype == SCIP_PARAMTYPE_CHAR: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * elif paramtype == SCIP_PARAMTYPE_STRING: + */ + goto __pyx_L4; + } + + /* "src/pyscipopt/scip.pxi":5230 + * elif paramtype == SCIP_PARAMTYPE_CHAR: + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * elif paramtype == SCIP_PARAMTYPE_STRING: # <<<<<<<<<<<<<< + * v = str_conversion(value) + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_STRING); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5231 + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * elif paramtype == SCIP_PARAMTYPE_STRING: + * v = str_conversion(value) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_value}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_v = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5232 + * elif paramtype == SCIP_PARAMTYPE_STRING: + * v = str_conversion(value) + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_n); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 5232, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyObject_AsWritableString(__pyx_v_v); if (unlikely((!__pyx_t_12) && PyErr_Occurred())) __PYX_ERR(0, 5232, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetStringParam(__pyx_v_self->_scip, __pyx_t_7, __pyx_t_12)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5230 + * elif paramtype == SCIP_PARAMTYPE_CHAR: + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * elif paramtype == SCIP_PARAMTYPE_STRING: # <<<<<<<<<<<<<< + * v = str_conversion(value) + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) + */ + } + __pyx_L4:; + + /* "src/pyscipopt/scip.pxi":5204 + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) + * + * def setParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a parameter with value in int, bool, real, long, char or str. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.setParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XDECREF(__pyx_v_v); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5235 + * + * + * def getParam(self, name): # <<<<<<<<<<<<<< + * """Get the value of a parameter of type + * int, bool, real, long, char or str. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_635getParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_634getParam, "Model.getParam(self, name)\nGet the value of a parameter of type\n int, bool, real, long, char or str.\n\n :param name: name of parameter\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_635getParam = {"getParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_635getParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_634getParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_635getParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5235, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "getParam") < 0)) __PYX_ERR(0, 5235, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("getParam", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5235, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.getParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_634getParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_634getParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name) { + SCIP_PARAM *__pyx_v_param; + PyObject *__pyx_v_n = NULL; + SCIP_PARAMTYPE __pyx_v_paramtype; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + int __pyx_t_6; + char *__pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getParam", 1); + + /* "src/pyscipopt/scip.pxi":5243 + * cdef SCIP_PARAM* param + * + * n = str_conversion(name) # <<<<<<<<<<<<<< + * param = SCIPgetParam(self._scip, n) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5244 + * + * n = str_conversion(name) + * param = SCIPgetParam(self._scip, n) # <<<<<<<<<<<<<< + * + * if param == NULL: + */ + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5244, __pyx_L1_error) + __pyx_v_param = SCIPgetParam(__pyx_v_self->_scip, __pyx_t_5); + + /* "src/pyscipopt/scip.pxi":5246 + * param = SCIPgetParam(self._scip, n) + * + * if param == NULL: # <<<<<<<<<<<<<< + * raise KeyError("Not a valid parameter name") + * + */ + __pyx_t_6 = (__pyx_v_param == NULL); + if (unlikely(__pyx_t_6)) { + + /* "src/pyscipopt/scip.pxi":5247 + * + * if param == NULL: + * raise KeyError("Not a valid parameter name") # <<<<<<<<<<<<<< + * + * paramtype = SCIPparamGetType(param) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__109, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 5247, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5246 + * param = SCIPgetParam(self._scip, n) + * + * if param == NULL: # <<<<<<<<<<<<<< + * raise KeyError("Not a valid parameter name") + * + */ + } + + /* "src/pyscipopt/scip.pxi":5249 + * raise KeyError("Not a valid parameter name") + * + * paramtype = SCIPparamGetType(param) # <<<<<<<<<<<<<< + * + * if paramtype == SCIP_PARAMTYPE_BOOL: + */ + __pyx_v_paramtype = SCIPparamGetType(__pyx_v_param); + + /* "src/pyscipopt/scip.pxi":5251 + * paramtype = SCIPparamGetType(param) + * + * if paramtype == SCIP_PARAMTYPE_BOOL: # <<<<<<<<<<<<<< + * return SCIPparamGetBool(param) + * elif paramtype == SCIP_PARAMTYPE_INT: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_BOOL); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5252 + * + * if paramtype == SCIP_PARAMTYPE_BOOL: + * return SCIPparamGetBool(param) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_INT: + * return SCIPparamGetInt(param) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(SCIPparamGetBool(__pyx_v_param)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5251 + * paramtype = SCIPparamGetType(param) + * + * if paramtype == SCIP_PARAMTYPE_BOOL: # <<<<<<<<<<<<<< + * return SCIPparamGetBool(param) + * elif paramtype == SCIP_PARAMTYPE_INT: + */ + } + + /* "src/pyscipopt/scip.pxi":5253 + * if paramtype == SCIP_PARAMTYPE_BOOL: + * return SCIPparamGetBool(param) + * elif paramtype == SCIP_PARAMTYPE_INT: # <<<<<<<<<<<<<< + * return SCIPparamGetInt(param) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_INT); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5254 + * return SCIPparamGetBool(param) + * elif paramtype == SCIP_PARAMTYPE_INT: + * return SCIPparamGetInt(param) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + * return SCIPparamGetLongint(param) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPparamGetInt(__pyx_v_param)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5253 + * if paramtype == SCIP_PARAMTYPE_BOOL: + * return SCIPparamGetBool(param) + * elif paramtype == SCIP_PARAMTYPE_INT: # <<<<<<<<<<<<<< + * return SCIPparamGetInt(param) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + */ + } + + /* "src/pyscipopt/scip.pxi":5255 + * elif paramtype == SCIP_PARAMTYPE_INT: + * return SCIPparamGetInt(param) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: # <<<<<<<<<<<<<< + * return SCIPparamGetLongint(param) + * elif paramtype == SCIP_PARAMTYPE_REAL: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_LONGINT); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5256 + * return SCIPparamGetInt(param) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + * return SCIPparamGetLongint(param) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_REAL: + * return SCIPparamGetReal(param) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_SCIP_Longint(SCIPparamGetLongint(__pyx_v_param)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5255 + * elif paramtype == SCIP_PARAMTYPE_INT: + * return SCIPparamGetInt(param) + * elif paramtype == SCIP_PARAMTYPE_LONGINT: # <<<<<<<<<<<<<< + * return SCIPparamGetLongint(param) + * elif paramtype == SCIP_PARAMTYPE_REAL: + */ + } + + /* "src/pyscipopt/scip.pxi":5257 + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + * return SCIPparamGetLongint(param) + * elif paramtype == SCIP_PARAMTYPE_REAL: # <<<<<<<<<<<<<< + * return SCIPparamGetReal(param) + * elif paramtype == SCIP_PARAMTYPE_CHAR: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_REAL); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5258 + * return SCIPparamGetLongint(param) + * elif paramtype == SCIP_PARAMTYPE_REAL: + * return SCIPparamGetReal(param) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_CHAR: + * return chr(SCIPparamGetChar(param)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPparamGetReal(__pyx_v_param)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5258, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5257 + * elif paramtype == SCIP_PARAMTYPE_LONGINT: + * return SCIPparamGetLongint(param) + * elif paramtype == SCIP_PARAMTYPE_REAL: # <<<<<<<<<<<<<< + * return SCIPparamGetReal(param) + * elif paramtype == SCIP_PARAMTYPE_CHAR: + */ + } + + /* "src/pyscipopt/scip.pxi":5259 + * elif paramtype == SCIP_PARAMTYPE_REAL: + * return SCIPparamGetReal(param) + * elif paramtype == SCIP_PARAMTYPE_CHAR: # <<<<<<<<<<<<<< + * return chr(SCIPparamGetChar(param)) + * elif paramtype == SCIP_PARAMTYPE_STRING: + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_CHAR); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5260 + * return SCIPparamGetReal(param) + * elif paramtype == SCIP_PARAMTYPE_CHAR: + * return chr(SCIPparamGetChar(param)) # <<<<<<<<<<<<<< + * elif paramtype == SCIP_PARAMTYPE_STRING: + * return SCIPparamGetString(param).decode('utf-8') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_char(SCIPparamGetChar(__pyx_v_param)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_chr, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5259 + * elif paramtype == SCIP_PARAMTYPE_REAL: + * return SCIPparamGetReal(param) + * elif paramtype == SCIP_PARAMTYPE_CHAR: # <<<<<<<<<<<<<< + * return chr(SCIPparamGetChar(param)) + * elif paramtype == SCIP_PARAMTYPE_STRING: + */ + } + + /* "src/pyscipopt/scip.pxi":5261 + * elif paramtype == SCIP_PARAMTYPE_CHAR: + * return chr(SCIPparamGetChar(param)) + * elif paramtype == SCIP_PARAMTYPE_STRING: # <<<<<<<<<<<<<< + * return SCIPparamGetString(param).decode('utf-8') + * + */ + __pyx_t_6 = (__pyx_v_paramtype == SCIP_PARAMTYPE_STRING); + if (__pyx_t_6) { + + /* "src/pyscipopt/scip.pxi":5262 + * return chr(SCIPparamGetChar(param)) + * elif paramtype == SCIP_PARAMTYPE_STRING: + * return SCIPparamGetString(param).decode('utf-8') # <<<<<<<<<<<<<< + * + * def getParams(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_7 = SCIPparamGetString(__pyx_v_param); + __pyx_t_8 = __Pyx_ssize_strlen(__pyx_t_7); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5262, __pyx_L1_error) + __pyx_t_2 = __Pyx_decode_c_string(__pyx_t_7, 0, __pyx_t_8, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5261 + * elif paramtype == SCIP_PARAMTYPE_CHAR: + * return chr(SCIPparamGetChar(param)) + * elif paramtype == SCIP_PARAMTYPE_STRING: # <<<<<<<<<<<<<< + * return SCIPparamGetString(param).decode('utf-8') + * + */ + } + + /* "src/pyscipopt/scip.pxi":5235 + * + * + * def getParam(self, name): # <<<<<<<<<<<<<< + * """Get the value of a parameter of type + * int, bool, real, long, char or str. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("pyscipopt.scip.Model.getParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5264 + * return SCIPparamGetString(param).decode('utf-8') + * + * def getParams(self): # <<<<<<<<<<<<<< + * """Gets the values of all parameters as a dict mapping parameter names + * to their values.""" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_637getParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_636getParams, "Model.getParams(self)\nGets the values of all parameters as a dict mapping parameter names\n to their values."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_637getParams = {"getParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_637getParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_636getParams}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_637getParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getParams (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getParams", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getParams", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_636getParams(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_636getParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_PARAM **__pyx_v_params; + PyObject *__pyx_v_result = NULL; + int __pyx_v_i; + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + char const *__pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getParams", 1); + + /* "src/pyscipopt/scip.pxi":5269 + * cdef SCIP_PARAM** params + * + * params = SCIPgetParams(self._scip) # <<<<<<<<<<<<<< + * result = {} + * for i in range(SCIPgetNParams(self._scip)): + */ + __pyx_v_params = SCIPgetParams(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":5270 + * + * params = SCIPgetParams(self._scip) + * result = {} # <<<<<<<<<<<<<< + * for i in range(SCIPgetNParams(self._scip)): + * name = SCIPparamGetName(params[i]).decode('utf-8') + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5271 + * params = SCIPgetParams(self._scip) + * result = {} + * for i in range(SCIPgetNParams(self._scip)): # <<<<<<<<<<<<<< + * name = SCIPparamGetName(params[i]).decode('utf-8') + * result[name] = self.getParam(name) + */ + __pyx_t_2 = SCIPgetNParams(__pyx_v_self->_scip); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "src/pyscipopt/scip.pxi":5272 + * result = {} + * for i in range(SCIPgetNParams(self._scip)): + * name = SCIPparamGetName(params[i]).decode('utf-8') # <<<<<<<<<<<<<< + * result[name] = self.getParam(name) + * return result + */ + __pyx_t_5 = SCIPparamGetName((__pyx_v_params[__pyx_v_i])); + __pyx_t_6 = __Pyx_ssize_strlen(__pyx_t_5); if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5272, __pyx_L1_error) + __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_5, 0, __pyx_t_6, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5273 + * for i in range(SCIPgetNParams(self._scip)): + * name = SCIPparamGetName(params[i]).decode('utf-8') + * result[name] = self.getParam(name) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getParam); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = NULL; + __pyx_t_9 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_9 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_9, 1+__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + if (unlikely((PyDict_SetItem(__pyx_v_result, __pyx_v_name, __pyx_t_1) < 0))) __PYX_ERR(0, 5273, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "src/pyscipopt/scip.pxi":5274 + * name = SCIPparamGetName(params[i]).decode('utf-8') + * result[name] = self.getParam(name) + * return result # <<<<<<<<<<<<<< + * + * def setParams(self, params): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5264 + * return SCIPparamGetString(param).decode('utf-8') + * + * def getParams(self): # <<<<<<<<<<<<<< + * """Gets the values of all parameters as a dict mapping parameter names + * to their values.""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.getParams", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5276 + * return result + * + * def setParams(self, params): # <<<<<<<<<<<<<< + * """Sets multiple parameters at once. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_639setParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_638setParams, "Model.setParams(self, params)\nSets multiple parameters at once.\n\n :param params: dict mapping parameter names to their values.\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_639setParams = {"setParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_639setParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_638setParams}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_639setParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_params = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setParams (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_params,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_params)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5276, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setParams") < 0)) __PYX_ERR(0, 5276, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_params = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setParams", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5276, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setParams", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_638setParams(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_params); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_638setParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_params) { + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_v_value = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setParams", 1); + + /* "src/pyscipopt/scip.pxi":5281 + * :param params: dict mapping parameter names to their values. + * """ + * for name, value in params.items(): # <<<<<<<<<<<<<< + * self.setParam(name, value) + * + */ + __pyx_t_2 = 0; + if (unlikely(__pyx_v_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 5281, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_params, 0, __pyx_n_s_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4); + if (unlikely(__pyx_t_7 == 0)) break; + if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 5281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_6); + __pyx_t_6 = 0; + + /* "src/pyscipopt/scip.pxi":5282 + * """ + * for name, value in params.items(): + * self.setParam(name, value) # <<<<<<<<<<<<<< + * + * def readParams(self, file): + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setParam); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_8, __pyx_v_name, __pyx_v_value}; + __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5276 + * return result + * + * def setParams(self, params): # <<<<<<<<<<<<<< + * """Sets multiple parameters at once. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("pyscipopt.scip.Model.setParams", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_value); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5284 + * self.setParam(name, value) + * + * def readParams(self, file): # <<<<<<<<<<<<<< + * """Read an external parameter file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_641readParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_640readParams, "Model.readParams(self, file)\nRead an external parameter file.\n\n :param file: file to be read\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_641readParams = {"readParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_641readParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_640readParams}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_641readParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_file = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readParams (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_file,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_file)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5284, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readParams") < 0)) __PYX_ERR(0, 5284, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_file = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("readParams", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5284, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.readParams", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_640readParams(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_file); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_640readParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_file) { + PyObject *__pyx_v_absfile = NULL; + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("readParams", 1); + + /* "src/pyscipopt/scip.pxi":5290 + * + * """ + * absfile = str_conversion(abspath(file)) # <<<<<<<<<<<<<< + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_abspath); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_file}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_t_4 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5290, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_absfile = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5292 + * absfile = str_conversion(abspath(file)) + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 5292, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5293 + * + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPreadParams(self._scip, absfile)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5295 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * PY_SCIP_CALL(SCIPreadParams(self._scip, absfile)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC, user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_AsWritableString(__pyx_v_absfile); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(0, 5295, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreadParams(__pyx_v_self->_scip, __pyx_t_7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 1+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5297 + * PY_SCIP_CALL(SCIPreadParams(self._scip, absfile)) + * + * locale.setlocale(locale.LC_NUMERIC, user_locale) # <<<<<<<<<<<<<< + * + * def writeParams(self, filename='param.set', comments=True, onlychanged=True, verbose=True): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_6 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_6 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5284 + * self.setParam(name, value) + * + * def readParams(self, file): # <<<<<<<<<<<<<< + * """Read an external parameter file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("pyscipopt.scip.Model.readParams", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_absfile); + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5299 + * locale.setlocale(locale.LC_NUMERIC, user_locale) + * + * def writeParams(self, filename='param.set', comments=True, onlychanged=True, verbose=True): # <<<<<<<<<<<<<< + * """Write parameter settings to an external file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_643writeParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_642writeParams, "Model.writeParams(self, filename=u'param.set', comments=True, onlychanged=True, verbose=True)\nWrite parameter settings to an external file.\n\n :param filename: file to be written (Default value = 'param.set')\n :param comments: write parameter descriptions as comments? (Default value = True)\n :param onlychanged: write only modified parameters (Default value = True)\n :param verbose: indicates whether a success message should be printed\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_643writeParams = {"writeParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_643writeParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_642writeParams}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_643writeParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_comments = 0; + PyObject *__pyx_v_onlychanged = 0; + PyObject *__pyx_v_verbose = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("writeParams (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_comments,&__pyx_n_s_onlychanged,&__pyx_n_s_verbose,0}; + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_kp_u_param_set)); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5299, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_comments); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5299, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_onlychanged); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5299, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_verbose); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5299, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "writeParams") < 0)) __PYX_ERR(0, 5299, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + __pyx_v_comments = values[1]; + __pyx_v_onlychanged = values[2]; + __pyx_v_verbose = values[3]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("writeParams", 0, 0, 4, __pyx_nargs); __PYX_ERR(0, 5299, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.writeParams", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_642writeParams(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename, __pyx_v_comments, __pyx_v_onlychanged, __pyx_v_verbose); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_642writeParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_comments, PyObject *__pyx_v_onlychanged, PyObject *__pyx_v_verbose) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_str_absfile = NULL; + PyObject *__pyx_v_absfile = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + char *__pyx_t_6; + SCIP_Bool __pyx_t_7; + SCIP_Bool __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("writeParams", 1); + + /* "src/pyscipopt/scip.pxi":5307 + * :param verbose: indicates whether a success message should be printed + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 5307, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5308 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * str_absfile = abspath(filename) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5310 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * str_absfile = abspath(filename) # <<<<<<<<<<<<<< + * absfile = str_conversion(str_absfile) + * PY_SCIP_CALL(SCIPwriteParams(self._scip, absfile, comments, onlychanged)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_abspath); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_filename}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5310, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_str_absfile = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5311 + * + * str_absfile = abspath(filename) + * absfile = str_conversion(str_absfile) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPwriteParams(self._scip, absfile, comments, onlychanged)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_str_absfile}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_absfile = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5312 + * str_absfile = abspath(filename) + * absfile = str_conversion(str_absfile) + * PY_SCIP_CALL(SCIPwriteParams(self._scip, absfile, comments, onlychanged)) # <<<<<<<<<<<<<< + * + * if verbose: + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_AsWritableString(__pyx_v_absfile); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(0, 5312, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_comments); if (unlikely((__pyx_t_7 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5312, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_onlychanged); if (unlikely((__pyx_t_8 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5312, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPwriteParams(__pyx_v_self->_scip, __pyx_t_6, __pyx_t_7, __pyx_t_8)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5312, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5314 + * PY_SCIP_CALL(SCIPwriteParams(self._scip, absfile, comments, onlychanged)) + * + * if verbose: # <<<<<<<<<<<<<< + * print('wrote parameter settings to file ' + str_absfile) + * + */ + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(0, 5314, __pyx_L1_error) + if (__pyx_t_9) { + + /* "src/pyscipopt/scip.pxi":5315 + * + * if verbose: + * print('wrote parameter settings to file ' + str_absfile) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) + */ + __pyx_t_4 = PyNumber_Add(__pyx_kp_u_wrote_parameter_settings_to_file, __pyx_v_str_absfile); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5314 + * PY_SCIP_CALL(SCIPwriteParams(self._scip, absfile, comments, onlychanged)) + * + * if verbose: # <<<<<<<<<<<<<< + * print('wrote parameter settings to file ' + str_absfile) + * + */ + } + + /* "src/pyscipopt/scip.pxi":5317 + * print('wrote parameter settings to file ' + str_absfile) + * + * locale.setlocale(locale.LC_NUMERIC,user_locale) # <<<<<<<<<<<<<< + * + * def resetParam(self, name): + */ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_locale); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_locale); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5299 + * locale.setlocale(locale.LC_NUMERIC, user_locale) + * + * def writeParams(self, filename='param.set', comments=True, onlychanged=True, verbose=True): # <<<<<<<<<<<<<< + * """Write parameter settings to an external file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.writeParams", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_str_absfile); + __Pyx_XDECREF(__pyx_v_absfile); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5319 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def resetParam(self, name): # <<<<<<<<<<<<<< + * """Reset parameter setting to its default value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_645resetParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_644resetParam, "Model.resetParam(self, name)\nReset parameter setting to its default value\n\n :param name: parameter to reset\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_645resetParam = {"resetParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_645resetParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_644resetParam}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_645resetParam(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("resetParam (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5319, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "resetParam") < 0)) __PYX_ERR(0, 5319, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("resetParam", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 5319, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.resetParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_644resetParam(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_644resetParam(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_name) { + PyObject *__pyx_v_n = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + char const *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("resetParam", 1); + + /* "src/pyscipopt/scip.pxi":5325 + * + * """ + * n = str_conversion(name) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPresetParam(self._scip, n)) + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_n = __pyx_t_1; + __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5326 + * """ + * n = str_conversion(name) + * PY_SCIP_CALL(SCIPresetParam(self._scip, n)) # <<<<<<<<<<<<<< + * + * def resetParams(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_n); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 5326, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPresetParam(__pyx_v_self->_scip, __pyx_t_5)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5319 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def resetParam(self, name): # <<<<<<<<<<<<<< + * """Reset parameter setting to its default value + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.resetParam", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_n); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5328 + * PY_SCIP_CALL(SCIPresetParam(self._scip, n)) + * + * def resetParams(self): # <<<<<<<<<<<<<< + * """Reset parameter settings to their default values""" + * PY_SCIP_CALL(SCIPresetParams(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_647resetParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_646resetParams, "Model.resetParams(self)\nReset parameter settings to their default values"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_647resetParams = {"resetParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_647resetParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_646resetParams}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_647resetParams(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("resetParams (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("resetParams", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "resetParams", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_646resetParams(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_646resetParams(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("resetParams", 1); + + /* "src/pyscipopt/scip.pxi":5330 + * def resetParams(self): + * """Reset parameter settings to their default values""" + * PY_SCIP_CALL(SCIPresetParams(self._scip)) # <<<<<<<<<<<<<< + * + * def setEmphasis(self, paraemphasis, quiet = True): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPresetParams(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5328 + * PY_SCIP_CALL(SCIPresetParam(self._scip, n)) + * + * def resetParams(self): # <<<<<<<<<<<<<< + * """Reset parameter settings to their default values""" + * PY_SCIP_CALL(SCIPresetParams(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.resetParams", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5332 + * PY_SCIP_CALL(SCIPresetParams(self._scip)) + * + * def setEmphasis(self, paraemphasis, quiet = True): # <<<<<<<<<<<<<< + * """Set emphasis settings + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_649setEmphasis(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_648setEmphasis, "Model.setEmphasis(self, paraemphasis, quiet=True)\nSet emphasis settings\n\n :param paraemphasis: emphasis to set\n :param quiet: hide output? (Default value = True)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_649setEmphasis = {"setEmphasis", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_649setEmphasis, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_648setEmphasis}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_649setEmphasis(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_paraemphasis = 0; + PyObject *__pyx_v_quiet = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setEmphasis (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_paraemphasis,&__pyx_n_s_quiet,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_True)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_paraemphasis)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5332, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_quiet); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5332, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "setEmphasis") < 0)) __PYX_ERR(0, 5332, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_paraemphasis = values[0]; + __pyx_v_quiet = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("setEmphasis", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 5332, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.setEmphasis", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_648setEmphasis(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_paraemphasis, __pyx_v_quiet); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_648setEmphasis(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_paraemphasis, PyObject *__pyx_v_quiet) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + SCIP_PARAMEMPHASIS __pyx_t_3; + SCIP_Bool __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setEmphasis", 1); + + /* "src/pyscipopt/scip.pxi":5339 + * + * """ + * PY_SCIP_CALL(SCIPsetEmphasis(self._scip, paraemphasis, quiet)) # <<<<<<<<<<<<<< + * + * def readProblem(self, filename, extension = None): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_As_SCIP_PARAMEMPHASIS(__pyx_v_paraemphasis); if (unlikely((__pyx_t_3 == ((SCIP_PARAMEMPHASIS)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5339, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_quiet); if (unlikely((__pyx_t_4 == ((SCIP_Bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5339, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetEmphasis(__pyx_v_self->_scip, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_7 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_7 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5339, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5332 + * PY_SCIP_CALL(SCIPresetParams(self._scip)) + * + * def setEmphasis(self, paraemphasis, quiet = True): # <<<<<<<<<<<<<< + * """Set emphasis settings + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.setEmphasis", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5341 + * PY_SCIP_CALL(SCIPsetEmphasis(self._scip, paraemphasis, quiet)) + * + * def readProblem(self, filename, extension = None): # <<<<<<<<<<<<<< + * """Read a problem instance from an external file. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_651readProblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_650readProblem, "Model.readProblem(self, filename, extension=None)\nRead a problem instance from an external file.\n\n :param filename: problem file name\n :param extension: specify file extension/type (Default value = None)\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_651readProblem = {"readProblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_651readProblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_650readProblem}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_651readProblem(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_filename = 0; + PyObject *__pyx_v_extension = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("readProblem (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_extension,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_filename)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5341, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_extension); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5341, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "readProblem") < 0)) __PYX_ERR(0, 5341, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_filename = values[0]; + __pyx_v_extension = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("readProblem", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 5341, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.readProblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_650readProblem(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_filename, __pyx_v_extension); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_650readProblem(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_extension) { + PyObject *__pyx_v_user_locale = NULL; + PyObject *__pyx_v_absfile = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + char *__pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("readProblem", 0); + __Pyx_INCREF(__pyx_v_extension); + + /* "src/pyscipopt/scip.pxi":5348 + * + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) # <<<<<<<<<<<<<< + * locale.setlocale(locale.LC_NUMERIC, "C") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_locale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_category, __pyx_t_4) < 0) __PYX_ERR(0, 5348, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_user_locale = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5349 + * """ + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + * locale.setlocale(locale.LC_NUMERIC, "C") # <<<<<<<<<<<<<< + * + * absfile = str_conversion(abspath(filename)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_locale); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_n_u_C}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5351 + * locale.setlocale(locale.LC_NUMERIC, "C") + * + * absfile = str_conversion(abspath(filename)) # <<<<<<<<<<<<<< + * if extension is None: + * PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, NULL)) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_abspath); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_filename}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_1, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_v_absfile = __pyx_t_4; + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5352 + * + * absfile = str_conversion(abspath(filename)) + * if extension is None: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, NULL)) + * else: + */ + __pyx_t_7 = (__pyx_v_extension == Py_None); + if (__pyx_t_7) { + + /* "src/pyscipopt/scip.pxi":5353 + * absfile = str_conversion(abspath(filename)) + * if extension is None: + * PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, NULL)) # <<<<<<<<<<<<<< + * else: + * extension = str_conversion(extension) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_AsWritableString(__pyx_v_absfile); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(0, 5353, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreadProb(__pyx_v_self->_scip, __pyx_t_8, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5352 + * + * absfile = str_conversion(abspath(filename)) + * if extension is None: # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, NULL)) + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5355 + * PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, NULL)) + * else: + * extension = str_conversion(extension) # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, extension)) + * + */ + /*else*/ { + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_str_conversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_extension}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5355, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF_SET(__pyx_v_extension, __pyx_t_4); + __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5356 + * else: + * extension = str_conversion(extension) + * PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, extension)) # <<<<<<<<<<<<<< + * + * locale.setlocale(locale.LC_NUMERIC, user_locale) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyObject_AsWritableString(__pyx_v_absfile); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(0, 5356, __pyx_L1_error) + __pyx_t_9 = __Pyx_PyObject_AsWritableString(__pyx_v_extension); if (unlikely((!__pyx_t_9) && PyErr_Occurred())) __PYX_ERR(0, 5356, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPreadProb(__pyx_v_self->_scip, __pyx_t_8, __pyx_t_9)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_1)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5356, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5358 + * PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, extension)) + * + * locale.setlocale(locale.LC_NUMERIC, user_locale) # <<<<<<<<<<<<<< + * + * # Counting functions + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_setlocale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_locale); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_LC_NUMERIC); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_t_1, __pyx_v_user_locale}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5358, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "src/pyscipopt/scip.pxi":5341 + * PY_SCIP_CALL(SCIPsetEmphasis(self._scip, paraemphasis, quiet)) + * + * def readProblem(self, filename, extension = None): # <<<<<<<<<<<<<< + * """Read a problem instance from an external file. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.readProblem", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_user_locale); + __Pyx_XDECREF(__pyx_v_absfile); + __Pyx_XDECREF(__pyx_v_extension); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5362 + * # Counting functions + * + * def count(self): # <<<<<<<<<<<<<< + * """Counts the number of feasible points of problem.""" + * PY_SCIP_CALL(SCIPcount(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_653count(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_652count, "Model.count(self)\nCounts the number of feasible points of problem."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_653count = {"count", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_653count, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_652count}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_653count(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("count (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("count", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "count", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_652count(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_652count(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("count", 1); + + /* "src/pyscipopt/scip.pxi":5364 + * def count(self): + * """Counts the number of feasible points of problem.""" + * PY_SCIP_CALL(SCIPcount(self._scip)) # <<<<<<<<<<<<<< + * + * def getNReaders(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPcount(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5362 + * # Counting functions + * + * def count(self): # <<<<<<<<<<<<<< + * """Counts the number of feasible points of problem.""" + * PY_SCIP_CALL(SCIPcount(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.count", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5366 + * PY_SCIP_CALL(SCIPcount(self._scip)) + * + * def getNReaders(self): # <<<<<<<<<<<<<< + * """Get number of currently available readers.""" + * return SCIPgetNReaders(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_655getNReaders(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_654getNReaders, "Model.getNReaders(self)\nGet number of currently available readers."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_655getNReaders = {"getNReaders", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_655getNReaders, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_654getNReaders}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_655getNReaders(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNReaders (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNReaders", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNReaders", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_654getNReaders(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_654getNReaders(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNReaders", 1); + + /* "src/pyscipopt/scip.pxi":5368 + * def getNReaders(self): + * """Get number of currently available readers.""" + * return SCIPgetNReaders(self._scip) # <<<<<<<<<<<<<< + * + * def getNCountedSols(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(SCIPgetNReaders(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5366 + * PY_SCIP_CALL(SCIPcount(self._scip)) + * + * def getNReaders(self): # <<<<<<<<<<<<<< + * """Get number of currently available readers.""" + * return SCIPgetNReaders(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNReaders", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5370 + * return SCIPgetNReaders(self._scip) + * + * def getNCountedSols(self): # <<<<<<<<<<<<<< + * """Get number of feasible solution.""" + * cdef SCIP_Bool valid + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_657getNCountedSols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_656getNCountedSols, "Model.getNCountedSols(self)\nGet number of feasible solution."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_657getNCountedSols = {"getNCountedSols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_657getNCountedSols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_656getNCountedSols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_657getNCountedSols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getNCountedSols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getNCountedSols", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getNCountedSols", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_656getNCountedSols(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_656getNCountedSols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + SCIP_Bool __pyx_v_valid; + SCIP_Longint __pyx_v_nsols; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getNCountedSols", 1); + + /* "src/pyscipopt/scip.pxi":5375 + * cdef SCIP_Longint nsols + * + * nsols = SCIPgetNCountedSols(self._scip, &valid) # <<<<<<<<<<<<<< + * if not valid: + * print('total number of solutions found is not valid!') + */ + __pyx_v_nsols = SCIPgetNCountedSols(__pyx_v_self->_scip, (&__pyx_v_valid)); + + /* "src/pyscipopt/scip.pxi":5376 + * + * nsols = SCIPgetNCountedSols(self._scip, &valid) + * if not valid: # <<<<<<<<<<<<<< + * print('total number of solutions found is not valid!') + * return nsols + */ + __pyx_t_1 = (!(__pyx_v_valid != 0)); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":5377 + * nsols = SCIPgetNCountedSols(self._scip, &valid) + * if not valid: + * print('total number of solutions found is not valid!') # <<<<<<<<<<<<<< + * return nsols + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__110, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5376 + * + * nsols = SCIPgetNCountedSols(self._scip, &valid) + * if not valid: # <<<<<<<<<<<<<< + * print('total number of solutions found is not valid!') + * return nsols + */ + } + + /* "src/pyscipopt/scip.pxi":5378 + * if not valid: + * print('total number of solutions found is not valid!') + * return nsols # <<<<<<<<<<<<<< + * + * def setParamsCountsols(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_SCIP_Longint(__pyx_v_nsols); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5370 + * return SCIPgetNReaders(self._scip) + * + * def getNCountedSols(self): # <<<<<<<<<<<<<< + * """Get number of feasible solution.""" + * cdef SCIP_Bool valid + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("pyscipopt.scip.Model.getNCountedSols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5380 + * return nsols + * + * def setParamsCountsols(self): # <<<<<<<<<<<<<< + * """Sets SCIP parameters such that a valid counting process is possible.""" + * PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_659setParamsCountsols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_658setParamsCountsols, "Model.setParamsCountsols(self)\nSets SCIP parameters such that a valid counting process is possible."); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_659setParamsCountsols = {"setParamsCountsols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_659setParamsCountsols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_658setParamsCountsols}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_659setParamsCountsols(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("setParamsCountsols (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("setParamsCountsols", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "setParamsCountsols", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_658setParamsCountsols(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_658setParamsCountsols(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setParamsCountsols", 1); + + /* "src/pyscipopt/scip.pxi":5382 + * def setParamsCountsols(self): + * """Sets SCIP parameters such that a valid counting process is possible.""" + * PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip)) # <<<<<<<<<<<<<< + * + * def freeReoptSolve(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPsetParamsCountsols(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5380 + * return nsols + * + * def setParamsCountsols(self): # <<<<<<<<<<<<<< + * """Sets SCIP parameters such that a valid counting process is possible.""" + * PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.setParamsCountsols", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5384 + * PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip)) + * + * def freeReoptSolve(self): # <<<<<<<<<<<<<< + * """Frees all solution process data and prepares for reoptimization""" + * PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip)) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_661freeReoptSolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_660freeReoptSolve, "Model.freeReoptSolve(self)\nFrees all solution process data and prepares for reoptimization"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_661freeReoptSolve = {"freeReoptSolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_661freeReoptSolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_660freeReoptSolve}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_661freeReoptSolve(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("freeReoptSolve (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("freeReoptSolve", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "freeReoptSolve", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_660freeReoptSolve(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_660freeReoptSolve(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("freeReoptSolve", 1); + + /* "src/pyscipopt/scip.pxi":5386 + * def freeReoptSolve(self): + * """Frees all solution process data and prepares for reoptimization""" + * PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip)) # <<<<<<<<<<<<<< + * + * def chgReoptObjective(self, coeffs, sense = 'minimize'): + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPfreeReoptSolve(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "src/pyscipopt/scip.pxi":5384 + * PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip)) + * + * def freeReoptSolve(self): # <<<<<<<<<<<<<< + * """Frees all solution process data and prepares for reoptimization""" + * PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip)) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.Model.freeReoptSolve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5388 + * PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip)) + * + * def chgReoptObjective(self, coeffs, sense = 'minimize'): # <<<<<<<<<<<<<< + * """Establish the objective function as a linear expression. + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_663chgReoptObjective(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_662chgReoptObjective, "Model.chgReoptObjective(self, coeffs, sense=u'minimize')\nEstablish the objective function as a linear expression.\n\n :param coeffs: the coefficients\n :param sense: the objective sense (Default value = 'minimize')\n\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_663chgReoptObjective = {"chgReoptObjective", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_663chgReoptObjective, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_662chgReoptObjective}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_663chgReoptObjective(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_coeffs = 0; + PyObject *__pyx_v_sense = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgReoptObjective (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_coeffs,&__pyx_n_s_sense,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)__pyx_n_u_minimize)); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_coeffs)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5388, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sense); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5388, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgReoptObjective") < 0)) __PYX_ERR(0, 5388, __pyx_L3_error) + } + } else { + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_coeffs = values[0]; + __pyx_v_sense = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgReoptObjective", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 5388, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgReoptObjective", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_662chgReoptObjective(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_coeffs, __pyx_v_sense); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_662chgReoptObjective(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_coeffs, PyObject *__pyx_v_sense) { + SCIP_OBJSENSE __pyx_v_objsense; + SCIP_VAR **__pyx_v__vars; + int __pyx_v__nvars; + SCIP_Real *__pyx_v__coeffs; + int __pyx_v_i; + PyObject *__pyx_v_term = NULL; + PyObject *__pyx_v_coef = NULL; + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + Py_ssize_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + SCIP_Real __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgReoptObjective", 1); + + /* "src/pyscipopt/scip.pxi":5398 + * cdef SCIP_OBJSENSE objsense + * + * if sense == "minimize": # <<<<<<<<<<<<<< + * objsense = SCIP_OBJSENSE_MINIMIZE + * elif sense == "maximize": + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_sense, __pyx_n_u_minimize, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 5398, __pyx_L1_error) + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":5399 + * + * if sense == "minimize": + * objsense = SCIP_OBJSENSE_MINIMIZE # <<<<<<<<<<<<<< + * elif sense == "maximize": + * objsense = SCIP_OBJSENSE_MAXIMIZE + */ + __pyx_v_objsense = SCIP_OBJSENSE_MINIMIZE; + + /* "src/pyscipopt/scip.pxi":5398 + * cdef SCIP_OBJSENSE objsense + * + * if sense == "minimize": # <<<<<<<<<<<<<< + * objsense = SCIP_OBJSENSE_MINIMIZE + * elif sense == "maximize": + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5400 + * if sense == "minimize": + * objsense = SCIP_OBJSENSE_MINIMIZE + * elif sense == "maximize": # <<<<<<<<<<<<<< + * objsense = SCIP_OBJSENSE_MAXIMIZE + * else: + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_sense, __pyx_n_u_maximize, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 5400, __pyx_L1_error) + if (likely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5401 + * objsense = SCIP_OBJSENSE_MINIMIZE + * elif sense == "maximize": + * objsense = SCIP_OBJSENSE_MAXIMIZE # <<<<<<<<<<<<<< + * else: + * raise Warning("unrecognized optimization sense: %s" % sense) + */ + __pyx_v_objsense = SCIP_OBJSENSE_MAXIMIZE; + + /* "src/pyscipopt/scip.pxi":5400 + * if sense == "minimize": + * objsense = SCIP_OBJSENSE_MINIMIZE + * elif sense == "maximize": # <<<<<<<<<<<<<< + * objsense = SCIP_OBJSENSE_MAXIMIZE + * else: + */ + goto __pyx_L3; + } + + /* "src/pyscipopt/scip.pxi":5403 + * objsense = SCIP_OBJSENSE_MAXIMIZE + * else: + * raise Warning("unrecognized optimization sense: %s" % sense) # <<<<<<<<<<<<<< + * + * assert isinstance(coeffs, Expr), "given coefficients are not Expr but %s" % coeffs.__class__.__name__ + */ + /*else*/ { + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unrecognized_optimization_sense, __pyx_v_sense); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_Warning, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5403, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 5403, __pyx_L1_error) + } + __pyx_L3:; + + /* "src/pyscipopt/scip.pxi":5405 + * raise Warning("unrecognized optimization sense: %s" % sense) + * + * assert isinstance(coeffs, Expr), "given coefficients are not Expr but %s" % coeffs.__class__.__name__ # <<<<<<<<<<<<<< + * + * if coeffs.degree() > 1: + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_coeffs, __pyx_ptype_9pyscipopt_4scip_Expr); + if (unlikely(!__pyx_t_1)) { + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_coeffs, __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_given_coefficients_are_not_Expr, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_3, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 5405, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 5405, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":5407 + * assert isinstance(coeffs, Expr), "given coefficients are not Expr but %s" % coeffs.__class__.__name__ + * + * if coeffs.degree() > 1: # <<<<<<<<<<<<<< + * raise ValueError("Nonlinear objective functions are not supported!") + * if coeffs[CONST] != 0.0: + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_coeffs, __pyx_n_s_degree); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_int_1, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5407, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 5407, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5408 + * + * if coeffs.degree() > 1: + * raise ValueError("Nonlinear objective functions are not supported!") # <<<<<<<<<<<<<< + * if coeffs[CONST] != 0.0: + * raise ValueError("Constant offsets in objective are not supported!") + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__111, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5408, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5407 + * assert isinstance(coeffs, Expr), "given coefficients are not Expr but %s" % coeffs.__class__.__name__ + * + * if coeffs.degree() > 1: # <<<<<<<<<<<<<< + * raise ValueError("Nonlinear objective functions are not supported!") + * if coeffs[CONST] != 0.0: + */ + } + + /* "src/pyscipopt/scip.pxi":5409 + * if coeffs.degree() > 1: + * raise ValueError("Nonlinear objective functions are not supported!") + * if coeffs[CONST] != 0.0: # <<<<<<<<<<<<<< + * raise ValueError("Constant offsets in objective are not supported!") + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_CONST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_coeffs, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = (__Pyx_PyFloat_BoolNeObjC(__pyx_t_3, __pyx_float_0_0, 0.0, 0, 0)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 5409, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__pyx_t_1)) { + + /* "src/pyscipopt/scip.pxi":5410 + * raise ValueError("Nonlinear objective functions are not supported!") + * if coeffs[CONST] != 0.0: + * raise ValueError("Constant offsets in objective are not supported!") # <<<<<<<<<<<<<< + * + * cdef SCIP_VAR** _vars + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__112, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(0, 5410, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5409 + * if coeffs.degree() > 1: + * raise ValueError("Nonlinear objective functions are not supported!") + * if coeffs[CONST] != 0.0: # <<<<<<<<<<<<<< + * raise ValueError("Constant offsets in objective are not supported!") + * + */ + } + + /* "src/pyscipopt/scip.pxi":5414 + * cdef SCIP_VAR** _vars + * cdef int _nvars + * _vars = SCIPgetOrigVars(self._scip) # <<<<<<<<<<<<<< + * _nvars = SCIPgetNOrigVars(self._scip) + * _coeffs = malloc(_nvars * sizeof(SCIP_Real)) + */ + __pyx_v__vars = SCIPgetOrigVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":5415 + * cdef int _nvars + * _vars = SCIPgetOrigVars(self._scip) + * _nvars = SCIPgetNOrigVars(self._scip) # <<<<<<<<<<<<<< + * _coeffs = malloc(_nvars * sizeof(SCIP_Real)) + * + */ + __pyx_v__nvars = SCIPgetNOrigVars(__pyx_v_self->_scip); + + /* "src/pyscipopt/scip.pxi":5416 + * _vars = SCIPgetOrigVars(self._scip) + * _nvars = SCIPgetNOrigVars(self._scip) + * _coeffs = malloc(_nvars * sizeof(SCIP_Real)) # <<<<<<<<<<<<<< + * + * for i in range(_nvars): + */ + __pyx_v__coeffs = ((SCIP_Real *)malloc((__pyx_v__nvars * (sizeof(SCIP_Real))))); + + /* "src/pyscipopt/scip.pxi":5418 + * _coeffs = malloc(_nvars * sizeof(SCIP_Real)) + * + * for i in range(_nvars): # <<<<<<<<<<<<<< + * _coeffs[i] = 0.0 + * + */ + __pyx_t_5 = __pyx_v__nvars; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_i = __pyx_t_7; + + /* "src/pyscipopt/scip.pxi":5419 + * + * for i in range(_nvars): + * _coeffs[i] = 0.0 # <<<<<<<<<<<<<< + * + * for term, coef in coeffs.terms.items(): + */ + (__pyx_v__coeffs[__pyx_v_i]) = 0.0; + } + + /* "src/pyscipopt/scip.pxi":5421 + * _coeffs[i] = 0.0 + * + * for term, coef in coeffs.terms.items(): # <<<<<<<<<<<<<< + * # avoid CONST term of Expr + * if term != CONST: + */ + __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_coeffs, __pyx_n_s_terms); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__pyx_t_2 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); + __PYX_ERR(0, 5421, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_dict_iterator(__pyx_t_2, 0, __pyx_n_s_items, (&__pyx_t_9), (&__pyx_t_5)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + while (1) { + __pyx_t_6 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_9, &__pyx_t_8, &__pyx_t_4, &__pyx_t_2, NULL, __pyx_t_5); + if (unlikely(__pyx_t_6 == 0)) break; + if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 5421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_term, __pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_coef, __pyx_t_2); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5423 + * for term, coef in coeffs.terms.items(): + * # avoid CONST term of Expr + * if term != CONST: # <<<<<<<<<<<<<< + * assert len(term) == 1 + * var = term[0] + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_CONST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_term, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5423, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 5423, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":5424 + * # avoid CONST term of Expr + * if term != CONST: + * assert len(term) == 1 # <<<<<<<<<<<<<< + * var = term[0] + * for i in range(_nvars): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_10 = PyObject_Length(__pyx_v_term); if (unlikely(__pyx_t_10 == ((Py_ssize_t)-1))) __PYX_ERR(0, 5424, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_10 == 1); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(__pyx_builtin_AssertionError, 0, 0, 0); + __PYX_ERR(0, 5424, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 5424, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":5425 + * if term != CONST: + * assert len(term) == 1 + * var = term[0] # <<<<<<<<<<<<<< + * for i in range(_nvars): + * if _vars[i] == var.scip_var: + */ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_term, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF_SET(__pyx_v_var, ((struct __pyx_obj_9pyscipopt_4scip_Variable *)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5426 + * assert len(term) == 1 + * var = term[0] + * for i in range(_nvars): # <<<<<<<<<<<<<< + * if _vars[i] == var.scip_var: + * _coeffs[i] = coef + */ + __pyx_t_6 = __pyx_v__nvars; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_7; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "src/pyscipopt/scip.pxi":5427 + * var = term[0] + * for i in range(_nvars): + * if _vars[i] == var.scip_var: # <<<<<<<<<<<<<< + * _coeffs[i] = coef + * + */ + __pyx_t_1 = ((__pyx_v__vars[__pyx_v_i]) == __pyx_v_var->scip_var); + if (__pyx_t_1) { + + /* "src/pyscipopt/scip.pxi":5428 + * for i in range(_nvars): + * if _vars[i] == var.scip_var: + * _coeffs[i] = coef # <<<<<<<<<<<<<< + * + * PY_SCIP_CALL(SCIPchgReoptObjective(self._scip, objsense, _vars, &_coeffs[0], _nvars)) + */ + __pyx_t_12 = __pyx_PyFloat_AsDouble(__pyx_v_coef); if (unlikely((__pyx_t_12 == ((SCIP_Real)-1)) && PyErr_Occurred())) __PYX_ERR(0, 5428, __pyx_L1_error) + (__pyx_v__coeffs[__pyx_v_i]) = __pyx_t_12; + + /* "src/pyscipopt/scip.pxi":5427 + * var = term[0] + * for i in range(_nvars): + * if _vars[i] == var.scip_var: # <<<<<<<<<<<<<< + * _coeffs[i] = coef + * + */ + } + } + + /* "src/pyscipopt/scip.pxi":5423 + * for term, coef in coeffs.terms.items(): + * # avoid CONST term of Expr + * if term != CONST: # <<<<<<<<<<<<<< + * assert len(term) == 1 + * var = term[0] + */ + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":5430 + * _coeffs[i] = coef + * + * PY_SCIP_CALL(SCIPchgReoptObjective(self._scip, objsense, _vars, &_coeffs[0], _nvars)) # <<<<<<<<<<<<<< + * + * free(_coeffs) + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgReoptObjective(__pyx_v_self->_scip, __pyx_v_objsense, __pyx_v__vars, (&(__pyx_v__coeffs[0])), __pyx_v__nvars)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_13 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_13)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_13); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":5432 + * PY_SCIP_CALL(SCIPchgReoptObjective(self._scip, objsense, _vars, &_coeffs[0], _nvars)) + * + * free(_coeffs) # <<<<<<<<<<<<<< + * + * def chgVarBranchPriority(self, Variable var, priority): + */ + free(__pyx_v__coeffs); + + /* "src/pyscipopt/scip.pxi":5388 + * PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip)) + * + * def chgReoptObjective(self, coeffs, sense = 'minimize'): # <<<<<<<<<<<<<< + * """Establish the objective function as a linear expression. + * + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgReoptObjective", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_term); + __Pyx_XDECREF(__pyx_v_coef); + __Pyx_XDECREF((PyObject *)__pyx_v_var); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5434 + * free(_coeffs) + * + * def chgVarBranchPriority(self, Variable var, priority): # <<<<<<<<<<<<<< + * """Sets the branch priority of the variable. + * Variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_665chgVarBranchPriority(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_664chgVarBranchPriority, "Model.chgVarBranchPriority(self, Variable var, priority)\nSets the branch priority of the variable.\n Variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable.\n\n :param Variable var: variable to change priority of\n :param priority: the new priority of the variable (the default branching priority is 0)\n "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_665chgVarBranchPriority = {"chgVarBranchPriority", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_665chgVarBranchPriority, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_664chgVarBranchPriority}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_665chgVarBranchPriority(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var = 0; + PyObject *__pyx_v_priority = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("chgVarBranchPriority (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_var,&__pyx_n_s_priority,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_var)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5434, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_priority)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 5434, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("chgVarBranchPriority", 1, 2, 2, 1); __PYX_ERR(0, 5434, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "chgVarBranchPriority") < 0)) __PYX_ERR(0, 5434, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + } + __pyx_v_var = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)values[0]); + __pyx_v_priority = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("chgVarBranchPriority", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 5434, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarBranchPriority", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable, 1, "var", 0))) __PYX_ERR(0, 5434, __pyx_L1_error) + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_664chgVarBranchPriority(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v_var, __pyx_v_priority); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_664chgVarBranchPriority(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, struct __pyx_obj_9pyscipopt_4scip_Variable *__pyx_v_var, PyObject *__pyx_v_priority) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("chgVarBranchPriority", 1); + + /* "src/pyscipopt/scip.pxi":5441 + * :param priority: the new priority of the variable (the default branching priority is 0) + * """ + * assert isinstance(var, Variable), "The given variable is not a pyvar, but %s" % var.__class__.__name__ # <<<<<<<<<<<<<< + * PY_SCIP_CALL(SCIPchgVarBranchPriority(self._scip, var.scip_var, priority)) + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_var), __pyx_ptype_9pyscipopt_4scip_Variable); + if (unlikely(!__pyx_t_1)) { + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_var), __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_The_given_variable_is_not_a_pyva, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_builtin_AssertionError, __pyx_t_2, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5441, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(0, 5441, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":5442 + * """ + * assert isinstance(var, Variable), "The given variable is not a pyvar, but %s" % var.__class__.__name__ + * PY_SCIP_CALL(SCIPchgVarBranchPriority(self._scip, var.scip_var, priority)) # <<<<<<<<<<<<<< + * + * def getTreesizeEstimation(self): + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PY_SCIP_CALL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_priority); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 5442, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_From_SCIP_RETCODE(SCIPchgVarBranchPriority(__pyx_v_self->_scip, __pyx_v_var->scip_var, __pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_4 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":5434 + * free(_coeffs) + * + * def chgVarBranchPriority(self, Variable var, priority): # <<<<<<<<<<<<<< + * """Sets the branch priority of the variable. + * Variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("pyscipopt.scip.Model.chgVarBranchPriority", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5444 + * PY_SCIP_CALL(SCIPchgVarBranchPriority(self._scip, var.scip_var, priority)) + * + * def getTreesizeEstimation(self): # <<<<<<<<<<<<<< + * """Get an estimation of the final tree size """ + * return SCIPgetTreesizeEstimation(self._scip) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_667getTreesizeEstimation(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_666getTreesizeEstimation, "Model.getTreesizeEstimation(self)\nGet an estimation of the final tree size "); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_667getTreesizeEstimation = {"getTreesizeEstimation", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_667getTreesizeEstimation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_666getTreesizeEstimation}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_667getTreesizeEstimation(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("getTreesizeEstimation (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("getTreesizeEstimation", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "getTreesizeEstimation", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_666getTreesizeEstimation(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_666getTreesizeEstimation(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("getTreesizeEstimation", 1); + + /* "src/pyscipopt/scip.pxi":5446 + * def getTreesizeEstimation(self): + * """Get an estimation of the final tree size """ + * return SCIPgetTreesizeEstimation(self._scip) # <<<<<<<<<<<<<< + * + * # debugging memory management + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyFloat_FromDouble(SCIPgetTreesizeEstimation(__pyx_v_self->_scip)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5444 + * PY_SCIP_CALL(SCIPchgVarBranchPriority(self._scip, var.scip_var, priority)) + * + * def getTreesizeEstimation(self): # <<<<<<<<<<<<<< + * """Get an estimation of the final tree size """ + * return SCIPgetTreesizeEstimation(self._scip) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.Model.getTreesizeEstimation", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "pyscipopt/scip.pxd":1951 + * cdef Solution _bestSol + * # can be used to store problem data + * cdef public object data # <<<<<<<<<<<<<< + * # make Model weak referentiable + * cdef object __weakref__ + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_4data___get__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_4data___get__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 1); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->data); + __pyx_r = __pyx_v_self->data; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Model_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Model_4data_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_4data_2__set__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Model_4data_2__set__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_9pyscipopt_4scip_5Model_4data_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_9pyscipopt_4scip_5Model_4data_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_4data_4__del__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_9pyscipopt_4scip_5Model_4data_4__del__(struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 1); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->data); + __Pyx_DECREF(__pyx_v_self->data); + __pyx_v_self->data = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_669__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_668__reduce_cython__, "Model.__reduce_cython__(self)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_669__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_669__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_668__reduce_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_669__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_668__reduce_cython__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_668__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 1); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__scip_self__valid_cannot_be, 0, 0); + __PYX_ERR(6, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Model.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_671__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_5Model_670__setstate_cython__, "Model.__setstate_cython__(self, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_5Model_671__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_671__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_670__setstate_cython__}; +static PyObject *__pyx_pw_9pyscipopt_4scip_5Model_671__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(6, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(6, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.Model.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_5Model_670__setstate_cython__(((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_5Model_670__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_9pyscipopt_4scip_Model *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 1); + + /* "(tree fragment)":4 + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< + */ + __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self__scip_self__valid_cannot_be, 0, 0); + __PYX_ERR(6, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("pyscipopt.scip.Model.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5449 + * + * # debugging memory management + * def is_memory_freed(): # <<<<<<<<<<<<<< + * return BMSgetMemoryUsed() == 0 + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_29is_memory_freed(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_28is_memory_freed, "is_memory_freed()"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_29is_memory_freed = {"is_memory_freed", (PyCFunction)__pyx_pw_9pyscipopt_4scip_29is_memory_freed, METH_NOARGS, __pyx_doc_9pyscipopt_4scip_28is_memory_freed}; +static PyObject *__pyx_pw_9pyscipopt_4scip_29is_memory_freed(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_memory_freed (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_28is_memory_freed(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_28is_memory_freed(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_memory_freed", 1); + + /* "src/pyscipopt/scip.pxi":5450 + * # debugging memory management + * def is_memory_freed(): + * return BMSgetMemoryUsed() == 0 # <<<<<<<<<<<<<< + * + * def print_memory_in_use(): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong((BMSgetMemoryUsed() == 0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5450, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "src/pyscipopt/scip.pxi":5449 + * + * # debugging memory management + * def is_memory_freed(): # <<<<<<<<<<<<<< + * return BMSgetMemoryUsed() == 0 + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("pyscipopt.scip.is_memory_freed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "src/pyscipopt/scip.pxi":5452 + * return BMSgetMemoryUsed() == 0 + * + * def print_memory_in_use(): # <<<<<<<<<<<<<< + * BMScheckEmptyMemory() + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_31print_memory_in_use(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_30print_memory_in_use, "print_memory_in_use()"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_31print_memory_in_use = {"print_memory_in_use", (PyCFunction)__pyx_pw_9pyscipopt_4scip_31print_memory_in_use, METH_NOARGS, __pyx_doc_9pyscipopt_4scip_30print_memory_in_use}; +static PyObject *__pyx_pw_9pyscipopt_4scip_31print_memory_in_use(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("print_memory_in_use (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_9pyscipopt_4scip_30print_memory_in_use(__pyx_self); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_30print_memory_in_use(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("print_memory_in_use", 1); + + /* "src/pyscipopt/scip.pxi":5453 + * + * def print_memory_in_use(): + * BMScheckEmptyMemory() # <<<<<<<<<<<<<< + */ + BMScheckEmptyMemory(); + + /* "src/pyscipopt/scip.pxi":5452 + * return BMSgetMemoryUsed() == 0 + * + * def print_memory_in_use(): # <<<<<<<<<<<<<< + * BMScheckEmptyMemory() + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Expr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_33__pyx_unpickle_Expr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_32__pyx_unpickle_Expr, "__pyx_unpickle_Expr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_33__pyx_unpickle_Expr = {"__pyx_unpickle_Expr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_33__pyx_unpickle_Expr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_32__pyx_unpickle_Expr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_33__pyx_unpickle_Expr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Expr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Expr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Expr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Expr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Expr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Expr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_32__pyx_unpickle_Expr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_32__pyx_unpickle_Expr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Expr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x51d2361, 0xce620d6, 0x6f493bf): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__113, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x51d2361, 0xce620d6, 0x6f493bf): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))" % __pyx_checksum + * __pyx_result = Expr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x51d2361, 0xce620d6, 0x6f493bf): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Expr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x51d2361, 0xce620d6, 0x6f493bf): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))" % __pyx_checksum + * __pyx_result = Expr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Expr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))" % __pyx_checksum + * __pyx_result = Expr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Expr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Expr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Expr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Expr__set_state(Expr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Expr__set_state(((struct __pyx_obj_9pyscipopt_4scip_Expr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))" % __pyx_checksum + * __pyx_result = Expr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Expr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Expr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Expr__set_state(Expr __pyx_result, tuple __pyx_state): + * __pyx_result.terms = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Expr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Expr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Expr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Expr__set_state(Expr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.terms = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Expr__set_state(struct __pyx_obj_9pyscipopt_4scip_Expr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Expr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Expr__set_state(Expr __pyx_result, tuple __pyx_state): + * __pyx_result.terms = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->terms); + __Pyx_DECREF(__pyx_v___pyx_result->terms); + __pyx_v___pyx_result->terms = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Expr__set_state(Expr __pyx_result, tuple __pyx_state): + * __pyx_result.terms = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.terms = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Expr__set_state(Expr __pyx_result, tuple __pyx_state): + * __pyx_result.terms = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Expr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Expr__set_state(Expr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.terms = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Expr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_ExprCons(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_35__pyx_unpickle_ExprCons(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_34__pyx_unpickle_ExprCons, "__pyx_unpickle_ExprCons(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_35__pyx_unpickle_ExprCons = {"__pyx_unpickle_ExprCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_35__pyx_unpickle_ExprCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_34__pyx_unpickle_ExprCons}; +static PyObject *__pyx_pw_9pyscipopt_4scip_35__pyx_unpickle_ExprCons(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_ExprCons (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ExprCons", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ExprCons", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_ExprCons") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ExprCons", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_ExprCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_34__pyx_unpickle_ExprCons(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_34__pyx_unpickle_ExprCons(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_ExprCons", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x8863d2c, 0x181c0f9, 0x8f4795b): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8863d2c, 0x181c0f9, 0x8f4795b) = (_lhs, _rhs, expr))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__115, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x8863d2c, 0x181c0f9, 0x8f4795b): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8863d2c, 0x181c0f9, 0x8f4795b) = (_lhs, _rhs, expr))" % __pyx_checksum + * __pyx_result = ExprCons.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x8863d2c, 0x181c0f9, 0x8f4795b): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8863d2c, 0x181c0f9, 0x8f4795b) = (_lhs, _rhs, expr))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = ExprCons.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x8863d2c, 0x181c0f9, 0x8f4795b): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8863d2c, 0x181c0f9, 0x8f4795b) = (_lhs, _rhs, expr))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8863d2c, 0x181c0f9, 0x8f4795b) = (_lhs, _rhs, expr))" % __pyx_checksum + * __pyx_result = ExprCons.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_ExprCons__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8863d2c, 0x181c0f9, 0x8f4795b) = (_lhs, _rhs, expr))" % __pyx_checksum + * __pyx_result = ExprCons.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_ExprCons__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = ExprCons.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_ExprCons__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_ExprCons__set_state(ExprCons __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_ExprCons__set_state(((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x8863d2c, 0x181c0f9, 0x8f4795b) = (_lhs, _rhs, expr))" % __pyx_checksum + * __pyx_result = ExprCons.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_ExprCons__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_ExprCons__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_ExprCons__set_state(ExprCons __pyx_result, tuple __pyx_state): + * __pyx_result._lhs = __pyx_state[0]; __pyx_result._rhs = __pyx_state[1]; __pyx_result.expr = __pyx_state[2] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_ExprCons(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_ExprCons", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_ExprCons__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_ExprCons__set_state(ExprCons __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._lhs = __pyx_state[0]; __pyx_result._rhs = __pyx_state[1]; __pyx_result.expr = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_ExprCons__set_state(struct __pyx_obj_9pyscipopt_4scip_ExprCons *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_ExprCons__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_ExprCons__set_state(ExprCons __pyx_result, tuple __pyx_state): + * __pyx_result._lhs = __pyx_state[0]; __pyx_result._rhs = __pyx_state[1]; __pyx_result.expr = __pyx_state[2] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_lhs); + __Pyx_DECREF(__pyx_v___pyx_result->_lhs); + __pyx_v___pyx_result->_lhs = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_rhs); + __Pyx_DECREF(__pyx_v___pyx_result->_rhs); + __pyx_v___pyx_result->_rhs = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->expr); + __Pyx_DECREF(__pyx_v___pyx_result->expr); + __pyx_v___pyx_result->expr = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_ExprCons__set_state(ExprCons __pyx_result, tuple __pyx_state): + * __pyx_result._lhs = __pyx_state[0]; __pyx_result._rhs = __pyx_state[1]; __pyx_result.expr = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 3); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result._lhs = __pyx_state[0]; __pyx_result._rhs = __pyx_state[1]; __pyx_result.expr = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_ExprCons__set_state(ExprCons __pyx_result, tuple __pyx_state): + * __pyx_result._lhs = __pyx_state[0]; __pyx_result._rhs = __pyx_state[1]; __pyx_result.expr = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_ExprCons__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_ExprCons__set_state(ExprCons __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._lhs = __pyx_state[0]; __pyx_result._rhs = __pyx_state[1]; __pyx_result.expr = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_ExprCons__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_GenExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_37__pyx_unpickle_GenExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_36__pyx_unpickle_GenExpr, "__pyx_unpickle_GenExpr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_37__pyx_unpickle_GenExpr = {"__pyx_unpickle_GenExpr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_37__pyx_unpickle_GenExpr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_36__pyx_unpickle_GenExpr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_37__pyx_unpickle_GenExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_GenExpr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_GenExpr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_GenExpr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_GenExpr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_GenExpr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_GenExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_36__pyx_unpickle_GenExpr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_36__pyx_unpickle_GenExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_GenExpr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xccaf182, 0xc6604dd, 0xa204a74): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__116, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xccaf182, 0xc6604dd, 0xa204a74): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + * __pyx_result = GenExpr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xccaf182, 0xc6604dd, 0xa204a74): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = GenExpr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xccaf182, 0xc6604dd, 0xa204a74): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + * __pyx_result = GenExpr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_GenExpr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + * __pyx_result = GenExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_GenExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = GenExpr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_GenExpr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_GenExpr__set_state(GenExpr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_GenExpr__set_state(((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + * __pyx_result = GenExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_GenExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_GenExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_GenExpr__set_state(GenExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_GenExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_GenExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_GenExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_GenExpr__set_state(GenExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_GenExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_GenExpr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_GenExpr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_GenExpr__set_state(GenExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_op); + __Pyx_DECREF(__pyx_v___pyx_result->_op); + __pyx_v___pyx_result->_op = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->children); + __Pyx_DECREF(__pyx_v___pyx_result->children); + __pyx_v___pyx_result->children = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_GenExpr__set_state(GenExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_GenExpr__set_state(GenExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_GenExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_GenExpr__set_state(GenExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_GenExpr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_SumExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_39__pyx_unpickle_SumExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_38__pyx_unpickle_SumExpr, "__pyx_unpickle_SumExpr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_39__pyx_unpickle_SumExpr = {"__pyx_unpickle_SumExpr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_39__pyx_unpickle_SumExpr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_38__pyx_unpickle_SumExpr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_39__pyx_unpickle_SumExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_SumExpr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_SumExpr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_SumExpr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_SumExpr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_SumExpr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_SumExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_38__pyx_unpickle_SumExpr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_38__pyx_unpickle_SumExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_SumExpr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x3c52fb7, 0x911913a, 0x6d57035): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3c52fb7, 0x911913a, 0x6d57035) = (_op, children, coefs, constant))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__117, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x3c52fb7, 0x911913a, 0x6d57035): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3c52fb7, 0x911913a, 0x6d57035) = (_op, children, coefs, constant))" % __pyx_checksum + * __pyx_result = SumExpr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x3c52fb7, 0x911913a, 0x6d57035): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3c52fb7, 0x911913a, 0x6d57035) = (_op, children, coefs, constant))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = SumExpr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x3c52fb7, 0x911913a, 0x6d57035): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3c52fb7, 0x911913a, 0x6d57035) = (_op, children, coefs, constant))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3c52fb7, 0x911913a, 0x6d57035) = (_op, children, coefs, constant))" % __pyx_checksum + * __pyx_result = SumExpr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_SumExpr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_SumExpr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3c52fb7, 0x911913a, 0x6d57035) = (_op, children, coefs, constant))" % __pyx_checksum + * __pyx_result = SumExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_SumExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = SumExpr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_SumExpr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_SumExpr__set_state(SumExpr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_SumExpr__set_state(((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x3c52fb7, 0x911913a, 0x6d57035) = (_op, children, coefs, constant))" % __pyx_checksum + * __pyx_result = SumExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_SumExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_SumExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_SumExpr__set_state(SumExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.coefs = __pyx_state[2]; __pyx_result.constant = __pyx_state[3] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_SumExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_SumExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_SumExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_SumExpr__set_state(SumExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.coefs = __pyx_state[2]; __pyx_result.constant = __pyx_state[3] + * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_SumExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_SumExpr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_SumExpr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_SumExpr__set_state(SumExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.coefs = __pyx_state[2]; __pyx_result.constant = __pyx_state[3] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[4]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base._op); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base._op); + __pyx_v___pyx_result->__pyx_base._op = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base.children); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base.children); + __pyx_v___pyx_result->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->coefs); + __Pyx_DECREF(__pyx_v___pyx_result->coefs); + __pyx_v___pyx_result->coefs = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->constant); + __Pyx_DECREF(__pyx_v___pyx_result->constant); + __pyx_v___pyx_result->constant = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_SumExpr__set_state(SumExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.coefs = __pyx_state[2]; __pyx_result.constant = __pyx_state[3] + * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[4]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 4); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.coefs = __pyx_state[2]; __pyx_result.constant = __pyx_state[3] + * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[4]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_SumExpr__set_state(SumExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.coefs = __pyx_state[2]; __pyx_result.constant = __pyx_state[3] + * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[4]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_SumExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_SumExpr__set_state(SumExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.coefs = __pyx_state[2]; __pyx_result.constant = __pyx_state[3] + * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_SumExpr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_ProdExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_41__pyx_unpickle_ProdExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_40__pyx_unpickle_ProdExpr, "__pyx_unpickle_ProdExpr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_41__pyx_unpickle_ProdExpr = {"__pyx_unpickle_ProdExpr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_41__pyx_unpickle_ProdExpr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_40__pyx_unpickle_ProdExpr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_41__pyx_unpickle_ProdExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_ProdExpr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ProdExpr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ProdExpr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_ProdExpr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_ProdExpr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_ProdExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_40__pyx_unpickle_ProdExpr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_40__pyx_unpickle_ProdExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_ProdExpr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe54af0a, 0xbfe881d, 0x0d1f1a0): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe54af0a, 0xbfe881d, 0x0d1f1a0) = (_op, children, constant))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__118, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe54af0a, 0xbfe881d, 0x0d1f1a0): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe54af0a, 0xbfe881d, 0x0d1f1a0) = (_op, children, constant))" % __pyx_checksum + * __pyx_result = ProdExpr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe54af0a, 0xbfe881d, 0x0d1f1a0): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe54af0a, 0xbfe881d, 0x0d1f1a0) = (_op, children, constant))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = ProdExpr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe54af0a, 0xbfe881d, 0x0d1f1a0): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe54af0a, 0xbfe881d, 0x0d1f1a0) = (_op, children, constant))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe54af0a, 0xbfe881d, 0x0d1f1a0) = (_op, children, constant))" % __pyx_checksum + * __pyx_result = ProdExpr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_ProdExpr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_ProdExpr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe54af0a, 0xbfe881d, 0x0d1f1a0) = (_op, children, constant))" % __pyx_checksum + * __pyx_result = ProdExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_ProdExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = ProdExpr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_ProdExpr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_ProdExpr__set_state(ProdExpr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_ProdExpr__set_state(((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe54af0a, 0xbfe881d, 0x0d1f1a0) = (_op, children, constant))" % __pyx_checksum + * __pyx_result = ProdExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_ProdExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_ProdExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_ProdExpr__set_state(ProdExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.constant = __pyx_state[2] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_ProdExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_ProdExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_ProdExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_ProdExpr__set_state(ProdExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.constant = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_ProdExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_ProdExpr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_ProdExpr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_ProdExpr__set_state(ProdExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.constant = __pyx_state[2] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base._op); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base._op); + __pyx_v___pyx_result->__pyx_base._op = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base.children); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base.children); + __pyx_v___pyx_result->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->constant); + __Pyx_DECREF(__pyx_v___pyx_result->constant); + __pyx_v___pyx_result->constant = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_ProdExpr__set_state(ProdExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.constant = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 3); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.constant = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_ProdExpr__set_state(ProdExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.constant = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_ProdExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_ProdExpr__set_state(ProdExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.constant = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_ProdExpr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_VarExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_43__pyx_unpickle_VarExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_42__pyx_unpickle_VarExpr, "__pyx_unpickle_VarExpr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_43__pyx_unpickle_VarExpr = {"__pyx_unpickle_VarExpr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_43__pyx_unpickle_VarExpr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_42__pyx_unpickle_VarExpr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_43__pyx_unpickle_VarExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_VarExpr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_VarExpr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_VarExpr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_VarExpr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_VarExpr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_VarExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_42__pyx_unpickle_VarExpr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_42__pyx_unpickle_VarExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_VarExpr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x496e932, 0x80e5b0b, 0xf1ef42d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x496e932, 0x80e5b0b, 0xf1ef42d) = (_op, children, var))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__119, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x496e932, 0x80e5b0b, 0xf1ef42d): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x496e932, 0x80e5b0b, 0xf1ef42d) = (_op, children, var))" % __pyx_checksum + * __pyx_result = VarExpr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x496e932, 0x80e5b0b, 0xf1ef42d): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x496e932, 0x80e5b0b, 0xf1ef42d) = (_op, children, var))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = VarExpr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x496e932, 0x80e5b0b, 0xf1ef42d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x496e932, 0x80e5b0b, 0xf1ef42d) = (_op, children, var))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x496e932, 0x80e5b0b, 0xf1ef42d) = (_op, children, var))" % __pyx_checksum + * __pyx_result = VarExpr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_VarExpr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_VarExpr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x496e932, 0x80e5b0b, 0xf1ef42d) = (_op, children, var))" % __pyx_checksum + * __pyx_result = VarExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_VarExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = VarExpr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_VarExpr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_VarExpr__set_state(VarExpr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_VarExpr__set_state(((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x496e932, 0x80e5b0b, 0xf1ef42d) = (_op, children, var))" % __pyx_checksum + * __pyx_result = VarExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_VarExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_VarExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_VarExpr__set_state(VarExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.var = __pyx_state[2] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_VarExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_VarExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_VarExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_VarExpr__set_state(VarExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.var = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_VarExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_VarExpr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_VarExpr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_VarExpr__set_state(VarExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.var = __pyx_state[2] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base._op); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base._op); + __pyx_v___pyx_result->__pyx_base._op = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base.children); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base.children); + __pyx_v___pyx_result->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->var); + __Pyx_DECREF(__pyx_v___pyx_result->var); + __pyx_v___pyx_result->var = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_VarExpr__set_state(VarExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.var = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 3); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.var = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_VarExpr__set_state(VarExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.var = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_VarExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_VarExpr__set_state(VarExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.var = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_VarExpr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PowExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_45__pyx_unpickle_PowExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_44__pyx_unpickle_PowExpr, "__pyx_unpickle_PowExpr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_45__pyx_unpickle_PowExpr = {"__pyx_unpickle_PowExpr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_45__pyx_unpickle_PowExpr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_44__pyx_unpickle_PowExpr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_45__pyx_unpickle_PowExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PowExpr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PowExpr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PowExpr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PowExpr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PowExpr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PowExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_44__pyx_unpickle_PowExpr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_44__pyx_unpickle_PowExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PowExpr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8) = (_op, children, expo))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__120, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8) = (_op, children, expo))" % __pyx_checksum + * __pyx_result = PowExpr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8) = (_op, children, expo))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PowExpr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_7, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8) = (_op, children, expo))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8) = (_op, children, expo))" % __pyx_checksum + * __pyx_result = PowExpr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PowExpr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PowExpr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8) = (_op, children, expo))" % __pyx_checksum + * __pyx_result = PowExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PowExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PowExpr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PowExpr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PowExpr__set_state(PowExpr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PowExpr__set_state(((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x4cfb19d, 0xa8a49a6, 0xa5e5fc8) = (_op, children, expo))" % __pyx_checksum + * __pyx_result = PowExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PowExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PowExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PowExpr__set_state(PowExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.expo = __pyx_state[2] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PowExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PowExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PowExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PowExpr__set_state(PowExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.expo = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PowExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_PowExpr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PowExpr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PowExpr__set_state(PowExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.expo = __pyx_state[2] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base._op); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base._op); + __pyx_v___pyx_result->__pyx_base._op = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base.children); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base.children); + __pyx_v___pyx_result->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->expo); + __Pyx_DECREF(__pyx_v___pyx_result->expo); + __pyx_v___pyx_result->expo = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PowExpr__set_state(PowExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.expo = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 3); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.expo = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PowExpr__set_state(PowExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.expo = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PowExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PowExpr__set_state(PowExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.expo = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PowExpr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_UnaryExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_47__pyx_unpickle_UnaryExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_46__pyx_unpickle_UnaryExpr, "__pyx_unpickle_UnaryExpr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_47__pyx_unpickle_UnaryExpr = {"__pyx_unpickle_UnaryExpr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_47__pyx_unpickle_UnaryExpr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_46__pyx_unpickle_UnaryExpr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_47__pyx_unpickle_UnaryExpr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_UnaryExpr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_UnaryExpr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_UnaryExpr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_UnaryExpr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_UnaryExpr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_UnaryExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_46__pyx_unpickle_UnaryExpr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_46__pyx_unpickle_UnaryExpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_UnaryExpr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xccaf182, 0xc6604dd, 0xa204a74): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__116, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xccaf182, 0xc6604dd, 0xa204a74): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + * __pyx_result = UnaryExpr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xccaf182, 0xc6604dd, 0xa204a74): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = UnaryExpr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xccaf182, 0xc6604dd, 0xa204a74): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + * __pyx_result = UnaryExpr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_UnaryExpr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + * __pyx_result = UnaryExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_UnaryExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = UnaryExpr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_UnaryExpr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_UnaryExpr__set_state(UnaryExpr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_UnaryExpr__set_state(((struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xccaf182, 0xc6604dd, 0xa204a74) = (_op, children))" % __pyx_checksum + * __pyx_result = UnaryExpr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_UnaryExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_UnaryExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_UnaryExpr__set_state(UnaryExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_UnaryExpr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_UnaryExpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_UnaryExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_UnaryExpr__set_state(UnaryExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_UnaryExpr__set_state(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_UnaryExpr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_UnaryExpr__set_state(UnaryExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base._op); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base._op); + __pyx_v___pyx_result->__pyx_base._op = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base.children); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base.children); + __pyx_v___pyx_result->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_UnaryExpr__set_state(UnaryExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_UnaryExpr__set_state(UnaryExpr __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_UnaryExpr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_UnaryExpr__set_state(UnaryExpr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_UnaryExpr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Constant(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_49__pyx_unpickle_Constant(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_48__pyx_unpickle_Constant, "__pyx_unpickle_Constant(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_49__pyx_unpickle_Constant = {"__pyx_unpickle_Constant", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_49__pyx_unpickle_Constant, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_48__pyx_unpickle_Constant}; +static PyObject *__pyx_pw_9pyscipopt_4scip_49__pyx_unpickle_Constant(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Constant (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Constant", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Constant", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Constant") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Constant", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Constant", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_48__pyx_unpickle_Constant(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_48__pyx_unpickle_Constant(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Constant", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x7e75df4, 0xc30431f, 0x8ccbbec): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x7e75df4, 0xc30431f, 0x8ccbbec) = (_op, children, number))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__121, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x7e75df4, 0xc30431f, 0x8ccbbec): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x7e75df4, 0xc30431f, 0x8ccbbec) = (_op, children, number))" % __pyx_checksum + * __pyx_result = Constant.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x7e75df4, 0xc30431f, 0x8ccbbec): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x7e75df4, 0xc30431f, 0x8ccbbec) = (_op, children, number))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Constant.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_8, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x7e75df4, 0xc30431f, 0x8ccbbec): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x7e75df4, 0xc30431f, 0x8ccbbec) = (_op, children, number))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x7e75df4, 0xc30431f, 0x8ccbbec) = (_op, children, number))" % __pyx_checksum + * __pyx_result = Constant.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Constant__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constant), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x7e75df4, 0xc30431f, 0x8ccbbec) = (_op, children, number))" % __pyx_checksum + * __pyx_result = Constant.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Constant__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Constant.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Constant__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Constant__set_state(Constant __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Constant__set_state(((struct __pyx_obj_9pyscipopt_4scip_Constant *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x7e75df4, 0xc30431f, 0x8ccbbec) = (_op, children, number))" % __pyx_checksum + * __pyx_result = Constant.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Constant__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Constant__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Constant__set_state(Constant __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.number = __pyx_state[2] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Constant(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Constant", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Constant__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Constant__set_state(Constant __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.number = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Constant__set_state(struct __pyx_obj_9pyscipopt_4scip_Constant *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Constant__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Constant__set_state(Constant __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.number = __pyx_state[2] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base._op); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base._op); + __pyx_v___pyx_result->__pyx_base._op = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->__pyx_base.children); + __Pyx_DECREF(__pyx_v___pyx_result->__pyx_base.children); + __pyx_v___pyx_result->__pyx_base.children = __pyx_t_1; + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->number); + __Pyx_DECREF(__pyx_v___pyx_result->number); + __pyx_v___pyx_result->number = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Constant__set_state(Constant __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.number = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 3); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.number = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Constant__set_state(Constant __pyx_result, tuple __pyx_state): + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.number = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Constant__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Constant__set_state(Constant __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.number = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Constant__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Benderscut(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_51__pyx_unpickle_Benderscut(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_50__pyx_unpickle_Benderscut, "__pyx_unpickle_Benderscut(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_51__pyx_unpickle_Benderscut = {"__pyx_unpickle_Benderscut", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_51__pyx_unpickle_Benderscut, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_50__pyx_unpickle_Benderscut}; +static PyObject *__pyx_pw_9pyscipopt_4scip_51__pyx_unpickle_Benderscut(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Benderscut (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Benderscut", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Benderscut", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Benderscut") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Benderscut", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Benderscut", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_50__pyx_unpickle_Benderscut(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_50__pyx_unpickle_Benderscut(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Benderscut", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x5af043b, 0xc68d043, 0xfef88e0): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5af043b, 0xc68d043, 0xfef88e0) = (benders, model, name))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__122, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x5af043b, 0xc68d043, 0xfef88e0): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5af043b, 0xc68d043, 0xfef88e0) = (benders, model, name))" % __pyx_checksum + * __pyx_result = Benderscut.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x5af043b, 0xc68d043, 0xfef88e0): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5af043b, 0xc68d043, 0xfef88e0) = (benders, model, name))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Benderscut.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_9, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x5af043b, 0xc68d043, 0xfef88e0): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5af043b, 0xc68d043, 0xfef88e0) = (benders, model, name))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5af043b, 0xc68d043, 0xfef88e0) = (benders, model, name))" % __pyx_checksum + * __pyx_result = Benderscut.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Benderscut__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5af043b, 0xc68d043, 0xfef88e0) = (benders, model, name))" % __pyx_checksum + * __pyx_result = Benderscut.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Benderscut__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Benderscut.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Benderscut__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Benderscut__set_state(Benderscut __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Benderscut__set_state(((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x5af043b, 0xc68d043, 0xfef88e0) = (benders, model, name))" % __pyx_checksum + * __pyx_result = Benderscut.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Benderscut__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Benderscut__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Benderscut__set_state(Benderscut __pyx_result, tuple __pyx_state): + * __pyx_result.benders = __pyx_state[0]; __pyx_result.model = __pyx_state[1]; __pyx_result.name = __pyx_state[2] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Benderscut(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Benderscut", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Benderscut__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Benderscut__set_state(Benderscut __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.benders = __pyx_state[0]; __pyx_result.model = __pyx_state[1]; __pyx_result.name = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Benderscut__set_state(struct __pyx_obj_9pyscipopt_4scip_Benderscut *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Benderscut__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Benderscut__set_state(Benderscut __pyx_result, tuple __pyx_state): + * __pyx_result.benders = __pyx_state[0]; __pyx_result.model = __pyx_state[1]; __pyx_result.name = __pyx_state[2] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Benders))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->benders); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->benders); + __pyx_v___pyx_result->benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_t_1))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Benderscut__set_state(Benderscut __pyx_result, tuple __pyx_state): + * __pyx_result.benders = __pyx_state[0]; __pyx_result.model = __pyx_state[1]; __pyx_result.name = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 3); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.benders = __pyx_state[0]; __pyx_result.model = __pyx_state[1]; __pyx_result.name = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[3]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Benderscut__set_state(Benderscut __pyx_result, tuple __pyx_state): + * __pyx_result.benders = __pyx_state[0]; __pyx_result.model = __pyx_state[1]; __pyx_result.name = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[3]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Benderscut__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Benderscut__set_state(Benderscut __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.benders = __pyx_state[0]; __pyx_result.model = __pyx_state[1]; __pyx_result.name = __pyx_state[2] + * if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Benderscut__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Branchrule(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_53__pyx_unpickle_Branchrule(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_52__pyx_unpickle_Branchrule, "__pyx_unpickle_Branchrule(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_53__pyx_unpickle_Branchrule = {"__pyx_unpickle_Branchrule", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_53__pyx_unpickle_Branchrule, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_52__pyx_unpickle_Branchrule}; +static PyObject *__pyx_pw_9pyscipopt_4scip_53__pyx_unpickle_Branchrule(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Branchrule (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Branchrule", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Branchrule", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Branchrule") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Branchrule", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Branchrule", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_52__pyx_unpickle_Branchrule(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_52__pyx_unpickle_Branchrule(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Branchrule", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__123, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Branchrule.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Branchrule.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Branchrule.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Branchrule__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Branchrule.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Branchrule__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Branchrule.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Branchrule__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Branchrule__set_state(Branchrule __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Branchrule__set_state(((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Branchrule.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Branchrule__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Branchrule__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Branchrule__set_state(Branchrule __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Branchrule(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Branchrule", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Branchrule__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Branchrule__set_state(Branchrule __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Branchrule__set_state(struct __pyx_obj_9pyscipopt_4scip_Branchrule *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Branchrule__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Branchrule__set_state(Branchrule __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Branchrule__set_state(Branchrule __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Branchrule__set_state(Branchrule __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Branchrule__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Branchrule__set_state(Branchrule __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Branchrule__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Conshdlr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_55__pyx_unpickle_Conshdlr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_54__pyx_unpickle_Conshdlr, "__pyx_unpickle_Conshdlr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_55__pyx_unpickle_Conshdlr = {"__pyx_unpickle_Conshdlr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_55__pyx_unpickle_Conshdlr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_54__pyx_unpickle_Conshdlr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_55__pyx_unpickle_Conshdlr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Conshdlr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Conshdlr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Conshdlr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Conshdlr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Conshdlr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Conshdlr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_54__pyx_unpickle_Conshdlr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_54__pyx_unpickle_Conshdlr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Conshdlr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__124, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Conshdlr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Conshdlr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Conshdlr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Conshdlr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Conshdlr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Conshdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Conshdlr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Conshdlr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Conshdlr__set_state(Conshdlr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Conshdlr__set_state(((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Conshdlr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Conshdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Conshdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Conshdlr__set_state(Conshdlr __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Conshdlr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Conshdlr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Conshdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Conshdlr__set_state(Conshdlr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Conshdlr__set_state(struct __pyx_obj_9pyscipopt_4scip_Conshdlr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Conshdlr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Conshdlr__set_state(Conshdlr __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_t_1))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Conshdlr__set_state(Conshdlr __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Conshdlr__set_state(Conshdlr __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Conshdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Conshdlr__set_state(Conshdlr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Conshdlr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Cutsel(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_57__pyx_unpickle_Cutsel(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_56__pyx_unpickle_Cutsel, "__pyx_unpickle_Cutsel(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_57__pyx_unpickle_Cutsel = {"__pyx_unpickle_Cutsel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_57__pyx_unpickle_Cutsel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_56__pyx_unpickle_Cutsel}; +static PyObject *__pyx_pw_9pyscipopt_4scip_57__pyx_unpickle_Cutsel(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Cutsel (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Cutsel", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Cutsel", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Cutsel") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Cutsel", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Cutsel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_56__pyx_unpickle_Cutsel(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_56__pyx_unpickle_Cutsel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Cutsel", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__123, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Cutsel.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Cutsel.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Cutsel.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Cutsel__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Cutsel.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Cutsel__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Cutsel.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Cutsel__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Cutsel__set_state(Cutsel __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Cutsel__set_state(((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Cutsel.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Cutsel__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Cutsel__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Cutsel__set_state(Cutsel __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Cutsel(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Cutsel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Cutsel__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Cutsel__set_state(Cutsel __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Cutsel__set_state(struct __pyx_obj_9pyscipopt_4scip_Cutsel *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Cutsel__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Cutsel__set_state(Cutsel __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Cutsel__set_state(Cutsel __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Cutsel__set_state(Cutsel __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Cutsel__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Cutsel__set_state(Cutsel __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Cutsel__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Eventhdlr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_59__pyx_unpickle_Eventhdlr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_58__pyx_unpickle_Eventhdlr, "__pyx_unpickle_Eventhdlr(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_59__pyx_unpickle_Eventhdlr = {"__pyx_unpickle_Eventhdlr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_59__pyx_unpickle_Eventhdlr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_58__pyx_unpickle_Eventhdlr}; +static PyObject *__pyx_pw_9pyscipopt_4scip_59__pyx_unpickle_Eventhdlr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Eventhdlr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Eventhdlr", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Eventhdlr", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Eventhdlr") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Eventhdlr", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Eventhdlr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_58__pyx_unpickle_Eventhdlr(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_58__pyx_unpickle_Eventhdlr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Eventhdlr", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__124, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Eventhdlr.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Eventhdlr.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Eventhdlr.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Eventhdlr__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Eventhdlr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Eventhdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Eventhdlr.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Eventhdlr__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Eventhdlr__set_state(Eventhdlr __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Eventhdlr__set_state(((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Eventhdlr.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Eventhdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Eventhdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Eventhdlr__set_state(Eventhdlr __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Eventhdlr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Eventhdlr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Eventhdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Eventhdlr__set_state(Eventhdlr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Eventhdlr__set_state(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Eventhdlr__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Eventhdlr__set_state(Eventhdlr __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_t_1))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Eventhdlr__set_state(Eventhdlr __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Eventhdlr__set_state(Eventhdlr __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Eventhdlr__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Eventhdlr__set_state(Eventhdlr __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Eventhdlr__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Heur(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_61__pyx_unpickle_Heur(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_60__pyx_unpickle_Heur, "__pyx_unpickle_Heur(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_61__pyx_unpickle_Heur = {"__pyx_unpickle_Heur", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_61__pyx_unpickle_Heur, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_60__pyx_unpickle_Heur}; +static PyObject *__pyx_pw_9pyscipopt_4scip_61__pyx_unpickle_Heur(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Heur (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Heur", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Heur", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Heur") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Heur", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Heur", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_60__pyx_unpickle_Heur(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_60__pyx_unpickle_Heur(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Heur", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__124, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Heur.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Heur.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Heur.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Heur__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Heur.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Heur__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Heur.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Heur__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Heur__set_state(Heur __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Heur__set_state(((struct __pyx_obj_9pyscipopt_4scip_Heur *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Heur.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Heur__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Heur__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Heur__set_state(Heur __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Heur(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Heur", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Heur__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Heur__set_state(Heur __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Heur__set_state(struct __pyx_obj_9pyscipopt_4scip_Heur *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Heur__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Heur__set_state(Heur __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_t_1))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Heur__set_state(Heur __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Heur__set_state(Heur __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Heur__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Heur__set_state(Heur __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Heur__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Presol(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_63__pyx_unpickle_Presol(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_62__pyx_unpickle_Presol, "__pyx_unpickle_Presol(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_63__pyx_unpickle_Presol = {"__pyx_unpickle_Presol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_63__pyx_unpickle_Presol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_62__pyx_unpickle_Presol}; +static PyObject *__pyx_pw_9pyscipopt_4scip_63__pyx_unpickle_Presol(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Presol (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Presol", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Presol", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Presol") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Presol", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Presol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_62__pyx_unpickle_Presol(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_62__pyx_unpickle_Presol(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Presol", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__123, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Presol.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Presol.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Presol.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Presol__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Presol.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Presol__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Presol.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Presol__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Presol__set_state(Presol __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Presol__set_state(((struct __pyx_obj_9pyscipopt_4scip_Presol *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Presol.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Presol__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Presol__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Presol__set_state(Presol __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Presol(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Presol", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Presol__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Presol__set_state(Presol __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Presol__set_state(struct __pyx_obj_9pyscipopt_4scip_Presol *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Presol__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Presol__set_state(Presol __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Presol__set_state(Presol __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Presol__set_state(Presol __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Presol__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Presol__set_state(Presol __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Presol__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Pricer(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_65__pyx_unpickle_Pricer(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_64__pyx_unpickle_Pricer, "__pyx_unpickle_Pricer(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_65__pyx_unpickle_Pricer = {"__pyx_unpickle_Pricer", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_65__pyx_unpickle_Pricer, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_64__pyx_unpickle_Pricer}; +static PyObject *__pyx_pw_9pyscipopt_4scip_65__pyx_unpickle_Pricer(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Pricer (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Pricer", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Pricer", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Pricer") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Pricer", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Pricer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_64__pyx_unpickle_Pricer(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_64__pyx_unpickle_Pricer(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Pricer", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__123, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Pricer.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Pricer.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Pricer.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Pricer__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Pricer.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Pricer__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Pricer.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Pricer__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Pricer__set_state(Pricer __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Pricer__set_state(((struct __pyx_obj_9pyscipopt_4scip_Pricer *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Pricer.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Pricer__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Pricer__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Pricer__set_state(Pricer __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Pricer(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Pricer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Pricer__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Pricer__set_state(Pricer __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Pricer__set_state(struct __pyx_obj_9pyscipopt_4scip_Pricer *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Pricer__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Pricer__set_state(Pricer __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Pricer__set_state(Pricer __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Pricer__set_state(Pricer __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Pricer__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Pricer__set_state(Pricer __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Pricer__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Prop(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_67__pyx_unpickle_Prop(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_66__pyx_unpickle_Prop, "__pyx_unpickle_Prop(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_67__pyx_unpickle_Prop = {"__pyx_unpickle_Prop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_67__pyx_unpickle_Prop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_66__pyx_unpickle_Prop}; +static PyObject *__pyx_pw_9pyscipopt_4scip_67__pyx_unpickle_Prop(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Prop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Prop", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Prop", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Prop") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Prop", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Prop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_66__pyx_unpickle_Prop(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_66__pyx_unpickle_Prop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Prop", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__123, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Prop.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Prop.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Prop.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Prop__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Prop.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Prop__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Prop.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Prop__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Prop__set_state(Prop __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Prop__set_state(((struct __pyx_obj_9pyscipopt_4scip_Prop *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Prop.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Prop__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Prop__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Prop__set_state(Prop __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Prop(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Prop", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Prop__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Prop__set_state(Prop __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Prop__set_state(struct __pyx_obj_9pyscipopt_4scip_Prop *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Prop__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Prop__set_state(Prop __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Prop__set_state(Prop __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Prop__set_state(Prop __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Prop__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Prop__set_state(Prop __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Prop__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Sepa(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_69__pyx_unpickle_Sepa(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_68__pyx_unpickle_Sepa, "__pyx_unpickle_Sepa(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_69__pyx_unpickle_Sepa = {"__pyx_unpickle_Sepa", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_69__pyx_unpickle_Sepa, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_68__pyx_unpickle_Sepa}; +static PyObject *__pyx_pw_9pyscipopt_4scip_69__pyx_unpickle_Sepa(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Sepa (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Sepa", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Sepa", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Sepa") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Sepa", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Sepa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_68__pyx_unpickle_Sepa(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_68__pyx_unpickle_Sepa(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Sepa", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__124, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Sepa.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Sepa.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Sepa.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Sepa__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Sepa.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Sepa__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Sepa.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Sepa__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Sepa__set_state(Sepa __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Sepa__set_state(((struct __pyx_obj_9pyscipopt_4scip_Sepa *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Sepa.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Sepa__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Sepa__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Sepa__set_state(Sepa __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Sepa(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Sepa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Sepa__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Sepa__set_state(Sepa __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Sepa__set_state(struct __pyx_obj_9pyscipopt_4scip_Sepa *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Sepa__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Sepa__set_state(Sepa __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_t_1))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Sepa__set_state(Sepa __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Sepa__set_state(Sepa __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Sepa__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Sepa__set_state(Sepa __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Sepa__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Reader(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_71__pyx_unpickle_Reader(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_70__pyx_unpickle_Reader, "__pyx_unpickle_Reader(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_71__pyx_unpickle_Reader = {"__pyx_unpickle_Reader", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_71__pyx_unpickle_Reader, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_70__pyx_unpickle_Reader}; +static PyObject *__pyx_pw_9pyscipopt_4scip_71__pyx_unpickle_Reader(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Reader (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Reader", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Reader", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Reader") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Reader", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Reader", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_70__pyx_unpickle_Reader(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_70__pyx_unpickle_Reader(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Reader", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__124, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Reader.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Reader.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Reader.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Reader__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Reader), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Reader.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Reader__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Reader.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Reader__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Reader__set_state(Reader __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Reader__set_state(((struct __pyx_obj_9pyscipopt_4scip_Reader *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Reader.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Reader__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Reader__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Reader__set_state(Reader __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Reader(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Reader", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Reader__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Reader__set_state(Reader __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Reader__set_state(struct __pyx_obj_9pyscipopt_4scip_Reader *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Reader__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Reader__set_state(Reader __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_t_1))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Reader__set_state(Reader __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Reader__set_state(Reader __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Reader__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Reader__set_state(Reader __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Reader__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Relax(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_73__pyx_unpickle_Relax(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_72__pyx_unpickle_Relax, "__pyx_unpickle_Relax(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_73__pyx_unpickle_Relax = {"__pyx_unpickle_Relax", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_73__pyx_unpickle_Relax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_72__pyx_unpickle_Relax}; +static PyObject *__pyx_pw_9pyscipopt_4scip_73__pyx_unpickle_Relax(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Relax (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Relax", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Relax", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Relax") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Relax", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Relax", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_72__pyx_unpickle_Relax(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_72__pyx_unpickle_Relax(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Relax", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__124, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Relax.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Relax.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x48f811e, 0x23d1325, 0xecd383d): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Relax.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Relax__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Relax.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Relax__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Relax.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Relax__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Relax__set_state(Relax __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Relax__set_state(((struct __pyx_obj_9pyscipopt_4scip_Relax *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x48f811e, 0x23d1325, 0xecd383d) = (model, name))" % __pyx_checksum + * __pyx_result = Relax.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Relax__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Relax__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Relax__set_state(Relax __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Relax(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Relax", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Relax__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Relax__set_state(Relax __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Relax__set_state(struct __pyx_obj_9pyscipopt_4scip_Relax *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Relax__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Relax__set_state(Relax __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("unicode", __pyx_t_1))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Relax__set_state(Relax __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Relax__set_state(Relax __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[2]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Relax__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Relax__set_state(Relax __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1] + * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Relax__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Nodesel(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_75__pyx_unpickle_Nodesel(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_74__pyx_unpickle_Nodesel, "__pyx_unpickle_Nodesel(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_75__pyx_unpickle_Nodesel = {"__pyx_unpickle_Nodesel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_75__pyx_unpickle_Nodesel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_74__pyx_unpickle_Nodesel}; +static PyObject *__pyx_pw_9pyscipopt_4scip_75__pyx_unpickle_Nodesel(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Nodesel (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Nodesel", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Nodesel", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_Nodesel") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Nodesel", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Nodesel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_74__pyx_unpickle_Nodesel(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_74__pyx_unpickle_Nodesel(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Nodesel", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__123, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Nodesel.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = Nodesel.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x9372c47, 0x1d06a0d, 0x20f35e6): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Nodesel.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Nodesel__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Nodesel.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Nodesel__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Nodesel.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Nodesel__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Nodesel__set_state(Nodesel __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_Nodesel__set_state(((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x9372c47, 0x1d06a0d, 0x20f35e6) = (model))" % __pyx_checksum + * __pyx_result = Nodesel.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Nodesel__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Nodesel__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Nodesel__set_state(Nodesel __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Nodesel(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Nodesel", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Nodesel__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Nodesel__set_state(Nodesel __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_Nodesel__set_state(struct __pyx_obj_9pyscipopt_4scip_Nodesel *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Nodesel__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Nodesel__set_state(Nodesel __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_9pyscipopt_4scip_Model))))) __PYX_ERR(6, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->model); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->model); + __pyx_v___pyx_result->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Nodesel__set_state(Nodesel __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 1); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(6, 13, __pyx_L1_error) + __pyx_t_2 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 14, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Nodesel__set_state(Nodesel __pyx_result, tuple __pyx_state): + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Nodesel__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Nodesel__set_state(Nodesel __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.model = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_Nodesel__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_RESULT(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_79__pyx_unpickle_PY_SCIP_RESULT(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_78__pyx_unpickle_PY_SCIP_RESULT, "__pyx_unpickle_PY_SCIP_RESULT(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_79__pyx_unpickle_PY_SCIP_RESULT = {"__pyx_unpickle_PY_SCIP_RESULT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_79__pyx_unpickle_PY_SCIP_RESULT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_78__pyx_unpickle_PY_SCIP_RESULT}; +static PyObject *__pyx_pw_9pyscipopt_4scip_79__pyx_unpickle_PY_SCIP_RESULT(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_RESULT (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_RESULT", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_RESULT", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_RESULT") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_RESULT", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_RESULT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_78__pyx_unpickle_PY_SCIP_RESULT(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_78__pyx_unpickle_PY_SCIP_RESULT(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_RESULT", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_RESULT.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_RESULT.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_RESULT.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_RESULT__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_RESULT.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_RESULT__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_RESULT.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_RESULT__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_RESULT__set_state(PY_SCIP_RESULT __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_RESULT__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_RESULT.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_RESULT__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_RESULT__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_RESULT__set_state(PY_SCIP_RESULT __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_RESULT(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_RESULT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_RESULT__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_RESULT__set_state(PY_SCIP_RESULT __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_RESULT__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_RESULT__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_RESULT__set_state(PY_SCIP_RESULT __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_RESULT__set_state(PY_SCIP_RESULT __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_RESULT__set_state(PY_SCIP_RESULT __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_RESULT__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_RESULT__set_state(PY_SCIP_RESULT __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_RESULT__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_PARAMSETTING(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_81__pyx_unpickle_PY_SCIP_PARAMSETTING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_80__pyx_unpickle_PY_SCIP_PARAMSETTING, "__pyx_unpickle_PY_SCIP_PARAMSETTING(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_81__pyx_unpickle_PY_SCIP_PARAMSETTING = {"__pyx_unpickle_PY_SCIP_PARAMSETTING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_81__pyx_unpickle_PY_SCIP_PARAMSETTING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_80__pyx_unpickle_PY_SCIP_PARAMSETTING}; +static PyObject *__pyx_pw_9pyscipopt_4scip_81__pyx_unpickle_PY_SCIP_PARAMSETTING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PARAMSETTING (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PARAMSETTING", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PARAMSETTING", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_PARAMSETTING") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PARAMSETTING", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PARAMSETTING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_80__pyx_unpickle_PY_SCIP_PARAMSETTING(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_80__pyx_unpickle_PY_SCIP_PARAMSETTING(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PARAMSETTING", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PARAMSETTING.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_PARAMSETTING.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PARAMSETTING.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PARAMSETTING.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_PARAMSETTING.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(PY_SCIP_PARAMSETTING __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PARAMSETTING.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(PY_SCIP_PARAMSETTING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_PARAMSETTING(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PARAMSETTING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(PY_SCIP_PARAMSETTING __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PARAMSETTING__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(PY_SCIP_PARAMSETTING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(PY_SCIP_PARAMSETTING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(PY_SCIP_PARAMSETTING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(PY_SCIP_PARAMSETTING __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PARAMSETTING__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_PARAMEMPHASIS(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_83__pyx_unpickle_PY_SCIP_PARAMEMPHASIS(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_82__pyx_unpickle_PY_SCIP_PARAMEMPHASIS, "__pyx_unpickle_PY_SCIP_PARAMEMPHASIS(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_83__pyx_unpickle_PY_SCIP_PARAMEMPHASIS = {"__pyx_unpickle_PY_SCIP_PARAMEMPHASIS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_83__pyx_unpickle_PY_SCIP_PARAMEMPHASIS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_82__pyx_unpickle_PY_SCIP_PARAMEMPHASIS}; +static PyObject *__pyx_pw_9pyscipopt_4scip_83__pyx_unpickle_PY_SCIP_PARAMEMPHASIS(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PARAMEMPHASIS (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PARAMEMPHASIS", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PARAMEMPHASIS", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_PARAMEMPHASIS") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PARAMEMPHASIS", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PARAMEMPHASIS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_82__pyx_unpickle_PY_SCIP_PARAMEMPHASIS(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_82__pyx_unpickle_PY_SCIP_PARAMEMPHASIS(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PARAMEMPHASIS", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PARAMEMPHASIS.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_PARAMEMPHASIS.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PARAMEMPHASIS.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PARAMEMPHASIS.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_PARAMEMPHASIS.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(PY_SCIP_PARAMEMPHASIS __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PARAMEMPHASIS.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(PY_SCIP_PARAMEMPHASIS __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_PARAMEMPHASIS(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PARAMEMPHASIS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(PY_SCIP_PARAMEMPHASIS __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(PY_SCIP_PARAMEMPHASIS __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(PY_SCIP_PARAMEMPHASIS __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(PY_SCIP_PARAMEMPHASIS __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(PY_SCIP_PARAMEMPHASIS __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_STATUS(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_85__pyx_unpickle_PY_SCIP_STATUS(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_84__pyx_unpickle_PY_SCIP_STATUS, "__pyx_unpickle_PY_SCIP_STATUS(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_85__pyx_unpickle_PY_SCIP_STATUS = {"__pyx_unpickle_PY_SCIP_STATUS", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_85__pyx_unpickle_PY_SCIP_STATUS, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_84__pyx_unpickle_PY_SCIP_STATUS}; +static PyObject *__pyx_pw_9pyscipopt_4scip_85__pyx_unpickle_PY_SCIP_STATUS(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_STATUS (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_STATUS", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_STATUS", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_STATUS") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_STATUS", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_STATUS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_84__pyx_unpickle_PY_SCIP_STATUS(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_84__pyx_unpickle_PY_SCIP_STATUS(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_STATUS", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_STATUS.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_STATUS.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_STATUS.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_STATUS__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_STATUS.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STATUS__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_STATUS.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_STATUS__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STATUS__set_state(PY_SCIP_STATUS __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_STATUS__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_STATUS.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STATUS__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_STATUS__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_STATUS__set_state(PY_SCIP_STATUS __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_STATUS(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_STATUS", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_STATUS__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STATUS__set_state(PY_SCIP_STATUS __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_STATUS__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_STATUS__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STATUS__set_state(PY_SCIP_STATUS __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_STATUS__set_state(PY_SCIP_STATUS __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STATUS__set_state(PY_SCIP_STATUS __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_STATUS__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STATUS__set_state(PY_SCIP_STATUS __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_STATUS__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_STAGE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_87__pyx_unpickle_PY_SCIP_STAGE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_86__pyx_unpickle_PY_SCIP_STAGE, "__pyx_unpickle_PY_SCIP_STAGE(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_87__pyx_unpickle_PY_SCIP_STAGE = {"__pyx_unpickle_PY_SCIP_STAGE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_87__pyx_unpickle_PY_SCIP_STAGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_86__pyx_unpickle_PY_SCIP_STAGE}; +static PyObject *__pyx_pw_9pyscipopt_4scip_87__pyx_unpickle_PY_SCIP_STAGE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_STAGE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_STAGE", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_STAGE", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_STAGE") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_STAGE", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_STAGE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_86__pyx_unpickle_PY_SCIP_STAGE(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_86__pyx_unpickle_PY_SCIP_STAGE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_STAGE", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_STAGE.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_STAGE.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_STAGE.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_STAGE__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_STAGE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STAGE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_STAGE.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_STAGE__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STAGE__set_state(PY_SCIP_STAGE __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_STAGE__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_STAGE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STAGE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_STAGE__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_STAGE__set_state(PY_SCIP_STAGE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_STAGE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_STAGE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_STAGE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STAGE__set_state(PY_SCIP_STAGE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_STAGE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_STAGE__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STAGE__set_state(PY_SCIP_STAGE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_STAGE__set_state(PY_SCIP_STAGE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STAGE__set_state(PY_SCIP_STAGE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_STAGE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_STAGE__set_state(PY_SCIP_STAGE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_STAGE__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_NODETYPE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_89__pyx_unpickle_PY_SCIP_NODETYPE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_88__pyx_unpickle_PY_SCIP_NODETYPE, "__pyx_unpickle_PY_SCIP_NODETYPE(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_89__pyx_unpickle_PY_SCIP_NODETYPE = {"__pyx_unpickle_PY_SCIP_NODETYPE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_89__pyx_unpickle_PY_SCIP_NODETYPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_88__pyx_unpickle_PY_SCIP_NODETYPE}; +static PyObject *__pyx_pw_9pyscipopt_4scip_89__pyx_unpickle_PY_SCIP_NODETYPE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_NODETYPE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_NODETYPE", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_NODETYPE", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_NODETYPE") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_NODETYPE", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_NODETYPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_88__pyx_unpickle_PY_SCIP_NODETYPE(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_88__pyx_unpickle_PY_SCIP_NODETYPE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_NODETYPE", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_NODETYPE.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_NODETYPE.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_NODETYPE.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_NODETYPE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_NODETYPE.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_NODETYPE__set_state(PY_SCIP_NODETYPE __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_NODETYPE__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_NODETYPE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_NODETYPE__set_state(PY_SCIP_NODETYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_NODETYPE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_NODETYPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_NODETYPE__set_state(PY_SCIP_NODETYPE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_NODETYPE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_NODETYPE__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_NODETYPE__set_state(PY_SCIP_NODETYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_NODETYPE__set_state(PY_SCIP_NODETYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_NODETYPE__set_state(PY_SCIP_NODETYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_NODETYPE__set_state(PY_SCIP_NODETYPE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_NODETYPE__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_PROPTIMING(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_91__pyx_unpickle_PY_SCIP_PROPTIMING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_90__pyx_unpickle_PY_SCIP_PROPTIMING, "__pyx_unpickle_PY_SCIP_PROPTIMING(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_91__pyx_unpickle_PY_SCIP_PROPTIMING = {"__pyx_unpickle_PY_SCIP_PROPTIMING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_91__pyx_unpickle_PY_SCIP_PROPTIMING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_90__pyx_unpickle_PY_SCIP_PROPTIMING}; +static PyObject *__pyx_pw_9pyscipopt_4scip_91__pyx_unpickle_PY_SCIP_PROPTIMING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PROPTIMING (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PROPTIMING", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PROPTIMING", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_PROPTIMING") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PROPTIMING", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PROPTIMING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_90__pyx_unpickle_PY_SCIP_PROPTIMING(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_90__pyx_unpickle_PY_SCIP_PROPTIMING(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PROPTIMING", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PROPTIMING.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_PROPTIMING.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PROPTIMING.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PROPTIMING.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_PROPTIMING.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(PY_SCIP_PROPTIMING __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PROPTIMING__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PROPTIMING.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(PY_SCIP_PROPTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_PROPTIMING(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PROPTIMING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(PY_SCIP_PROPTIMING __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PROPTIMING__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PROPTIMING__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(PY_SCIP_PROPTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(PY_SCIP_PROPTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(PY_SCIP_PROPTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(PY_SCIP_PROPTIMING __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PROPTIMING__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_PRESOLTIMING(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_93__pyx_unpickle_PY_SCIP_PRESOLTIMING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_92__pyx_unpickle_PY_SCIP_PRESOLTIMING, "__pyx_unpickle_PY_SCIP_PRESOLTIMING(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_93__pyx_unpickle_PY_SCIP_PRESOLTIMING = {"__pyx_unpickle_PY_SCIP_PRESOLTIMING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_93__pyx_unpickle_PY_SCIP_PRESOLTIMING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_92__pyx_unpickle_PY_SCIP_PRESOLTIMING}; +static PyObject *__pyx_pw_9pyscipopt_4scip_93__pyx_unpickle_PY_SCIP_PRESOLTIMING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PRESOLTIMING (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PRESOLTIMING", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PRESOLTIMING", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_PRESOLTIMING") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_PRESOLTIMING", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PRESOLTIMING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_92__pyx_unpickle_PY_SCIP_PRESOLTIMING(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_92__pyx_unpickle_PY_SCIP_PRESOLTIMING(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PRESOLTIMING", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PRESOLTIMING.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_PRESOLTIMING.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PRESOLTIMING.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PRESOLTIMING.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_PRESOLTIMING.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(PY_SCIP_PRESOLTIMING __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_PRESOLTIMING.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(PY_SCIP_PRESOLTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_PRESOLTIMING(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PRESOLTIMING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(PY_SCIP_PRESOLTIMING __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(PY_SCIP_PRESOLTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(PY_SCIP_PRESOLTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(PY_SCIP_PRESOLTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(PY_SCIP_PRESOLTIMING __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_HEURTIMING(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_95__pyx_unpickle_PY_SCIP_HEURTIMING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_94__pyx_unpickle_PY_SCIP_HEURTIMING, "__pyx_unpickle_PY_SCIP_HEURTIMING(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_95__pyx_unpickle_PY_SCIP_HEURTIMING = {"__pyx_unpickle_PY_SCIP_HEURTIMING", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_95__pyx_unpickle_PY_SCIP_HEURTIMING, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_94__pyx_unpickle_PY_SCIP_HEURTIMING}; +static PyObject *__pyx_pw_9pyscipopt_4scip_95__pyx_unpickle_PY_SCIP_HEURTIMING(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_HEURTIMING (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_HEURTIMING", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_HEURTIMING", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_HEURTIMING") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_HEURTIMING", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_HEURTIMING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_94__pyx_unpickle_PY_SCIP_HEURTIMING(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_94__pyx_unpickle_PY_SCIP_HEURTIMING(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_HEURTIMING", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_HEURTIMING.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_HEURTIMING.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_HEURTIMING.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_HEURTIMING.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_HEURTIMING.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(PY_SCIP_HEURTIMING __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_HEURTIMING__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_HEURTIMING.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(PY_SCIP_HEURTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_HEURTIMING(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_HEURTIMING", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(PY_SCIP_HEURTIMING __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_HEURTIMING__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_HEURTIMING__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(PY_SCIP_HEURTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(PY_SCIP_HEURTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(PY_SCIP_HEURTIMING __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(PY_SCIP_HEURTIMING __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_HEURTIMING__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_EVENTTYPE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_97__pyx_unpickle_PY_SCIP_EVENTTYPE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_96__pyx_unpickle_PY_SCIP_EVENTTYPE, "__pyx_unpickle_PY_SCIP_EVENTTYPE(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_97__pyx_unpickle_PY_SCIP_EVENTTYPE = {"__pyx_unpickle_PY_SCIP_EVENTTYPE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_97__pyx_unpickle_PY_SCIP_EVENTTYPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_96__pyx_unpickle_PY_SCIP_EVENTTYPE}; +static PyObject *__pyx_pw_9pyscipopt_4scip_97__pyx_unpickle_PY_SCIP_EVENTTYPE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_EVENTTYPE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_EVENTTYPE", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_EVENTTYPE", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_EVENTTYPE") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_EVENTTYPE", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_EVENTTYPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_96__pyx_unpickle_PY_SCIP_EVENTTYPE(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_96__pyx_unpickle_PY_SCIP_EVENTTYPE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_EVENTTYPE", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_EVENTTYPE.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_EVENTTYPE.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_EVENTTYPE.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_EVENTTYPE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_EVENTTYPE.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(PY_SCIP_EVENTTYPE __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_EVENTTYPE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(PY_SCIP_EVENTTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_EVENTTYPE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_EVENTTYPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(PY_SCIP_EVENTTYPE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_EVENTTYPE__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(PY_SCIP_EVENTTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(PY_SCIP_EVENTTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(PY_SCIP_EVENTTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(PY_SCIP_EVENTTYPE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_EVENTTYPE__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_LPSOLSTAT(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_99__pyx_unpickle_PY_SCIP_LPSOLSTAT(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_98__pyx_unpickle_PY_SCIP_LPSOLSTAT, "__pyx_unpickle_PY_SCIP_LPSOLSTAT(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_99__pyx_unpickle_PY_SCIP_LPSOLSTAT = {"__pyx_unpickle_PY_SCIP_LPSOLSTAT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_99__pyx_unpickle_PY_SCIP_LPSOLSTAT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_98__pyx_unpickle_PY_SCIP_LPSOLSTAT}; +static PyObject *__pyx_pw_9pyscipopt_4scip_99__pyx_unpickle_PY_SCIP_LPSOLSTAT(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_LPSOLSTAT (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_LPSOLSTAT", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_LPSOLSTAT", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_LPSOLSTAT") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_LPSOLSTAT", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_LPSOLSTAT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_98__pyx_unpickle_PY_SCIP_LPSOLSTAT(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_98__pyx_unpickle_PY_SCIP_LPSOLSTAT(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_LPSOLSTAT", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_LPSOLSTAT.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_LPSOLSTAT.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_LPSOLSTAT.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_LPSOLSTAT.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_LPSOLSTAT.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(PY_SCIP_LPSOLSTAT __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_LPSOLSTAT.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(PY_SCIP_LPSOLSTAT __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_LPSOLSTAT(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_LPSOLSTAT", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(PY_SCIP_LPSOLSTAT __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(PY_SCIP_LPSOLSTAT __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(PY_SCIP_LPSOLSTAT __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(PY_SCIP_LPSOLSTAT __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(PY_SCIP_LPSOLSTAT __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_BRANCHDIR(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_101__pyx_unpickle_PY_SCIP_BRANCHDIR(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_100__pyx_unpickle_PY_SCIP_BRANCHDIR, "__pyx_unpickle_PY_SCIP_BRANCHDIR(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_101__pyx_unpickle_PY_SCIP_BRANCHDIR = {"__pyx_unpickle_PY_SCIP_BRANCHDIR", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_101__pyx_unpickle_PY_SCIP_BRANCHDIR, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_100__pyx_unpickle_PY_SCIP_BRANCHDIR}; +static PyObject *__pyx_pw_9pyscipopt_4scip_101__pyx_unpickle_PY_SCIP_BRANCHDIR(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_BRANCHDIR (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_BRANCHDIR", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_BRANCHDIR", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_BRANCHDIR") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_BRANCHDIR", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_BRANCHDIR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_100__pyx_unpickle_PY_SCIP_BRANCHDIR(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_100__pyx_unpickle_PY_SCIP_BRANCHDIR(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_BRANCHDIR", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_BRANCHDIR.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_BRANCHDIR.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_BRANCHDIR.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_BRANCHDIR.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_BRANCHDIR.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(PY_SCIP_BRANCHDIR __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_BRANCHDIR.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(PY_SCIP_BRANCHDIR __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_BRANCHDIR(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_BRANCHDIR", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(PY_SCIP_BRANCHDIR __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_BRANCHDIR__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(PY_SCIP_BRANCHDIR __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(PY_SCIP_BRANCHDIR __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(PY_SCIP_BRANCHDIR __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(PY_SCIP_BRANCHDIR __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_BRANCHDIR__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_103__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_102__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, "__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_103__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE = {"__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_103__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_102__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE}; +static PyObject *__pyx_pw_9pyscipopt_4scip_103__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_102__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_102__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_BENDERSENFOTYPE.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_BENDERSENFOTYPE.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_BENDERSENFOTYPE.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_BENDERSENFOTYPE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_BENDERSENFOTYPE.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(PY_SCIP_BENDERSENFOTYPE __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_BENDERSENFOTYPE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(PY_SCIP_BENDERSENFOTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(PY_SCIP_BENDERSENFOTYPE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(PY_SCIP_BENDERSENFOTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(PY_SCIP_BENDERSENFOTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(PY_SCIP_BENDERSENFOTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(PY_SCIP_BENDERSENFOTYPE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_ROWORIGINTYPE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_9pyscipopt_4scip_105__pyx_unpickle_PY_SCIP_ROWORIGINTYPE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_9pyscipopt_4scip_104__pyx_unpickle_PY_SCIP_ROWORIGINTYPE, "__pyx_unpickle_PY_SCIP_ROWORIGINTYPE(__pyx_type, long __pyx_checksum, __pyx_state)"); +static PyMethodDef __pyx_mdef_9pyscipopt_4scip_105__pyx_unpickle_PY_SCIP_ROWORIGINTYPE = {"__pyx_unpickle_PY_SCIP_ROWORIGINTYPE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_105__pyx_unpickle_PY_SCIP_ROWORIGINTYPE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_104__pyx_unpickle_PY_SCIP_ROWORIGINTYPE}; +static PyObject *__pyx_pw_9pyscipopt_4scip_105__pyx_unpickle_PY_SCIP_ROWORIGINTYPE(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_ROWORIGINTYPE (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_ROWORIGINTYPE", 1, 3, 3, 1); __PYX_ERR(6, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_ROWORIGINTYPE", 1, 3, 3, 2); __PYX_ERR(6, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle_PY_SCIP_ROWORIGINTYPE") < 0)) __PYX_ERR(6, 1, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PY_SCIP_ROWORIGINTYPE", 1, 3, 3, __pyx_nargs); __PYX_ERR(6, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_ROWORIGINTYPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_9pyscipopt_4scip_104__pyx_unpickle_PY_SCIP_ROWORIGINTYPE(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_9pyscipopt_4scip_104__pyx_unpickle_PY_SCIP_ROWORIGINTYPE(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_ROWORIGINTYPE", 1); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__125, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_ROWORIGINTYPE.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(6, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum # <<<<<<<<<<<<<< + * __pyx_result = PY_SCIP_ROWORIGINTYPE.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(6, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xe3b0c44, 0xda39a3e, 0xd41d8cd): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_ROWORIGINTYPE.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_ROWORIGINTYPE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = PY_SCIP_ROWORIGINTYPE.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(PY_SCIP_ROWORIGINTYPE __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(6, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(((struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0xe3b0c44, 0xda39a3e, 0xd41d8cd) = ())" % __pyx_checksum + * __pyx_result = PY_SCIP_ROWORIGINTYPE.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(PY_SCIP_ROWORIGINTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_PY_SCIP_ROWORIGINTYPE(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_ROWORIGINTYPE", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(PY_SCIP_ROWORIGINTYPE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + +static PyObject *__pyx_f_9pyscipopt_4scip___pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state", 1); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(PY_SCIP_ROWORIGINTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(6, 12, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_3 = (__pyx_t_2 > 0); + if (__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(6, 12, __pyx_L1_error) + __pyx_t_1 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(PY_SCIP_ROWORIGINTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) # <<<<<<<<<<<<<< + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_update); if (unlikely(!__pyx_t_6)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(6, 13, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_8 = 1; + } + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_6, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(PY_SCIP_ROWORIGINTYPE __pyx_result, tuple __pyx_state): + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(PY_SCIP_ROWORIGINTYPE __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[0]) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("pyscipopt.scip.__pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Expr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Expr *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Expr *)o); + p->terms = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Expr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Expr *p = (struct __pyx_obj_9pyscipopt_4scip_Expr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Expr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->terms); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Expr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Expr *p = (struct __pyx_obj_9pyscipopt_4scip_Expr *)o; + if (p->terms) { + e = (*v)(p->terms, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Expr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Expr *p = (struct __pyx_obj_9pyscipopt_4scip_Expr *)o; + tmp = ((PyObject*)p->terms); + p->terms = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +static PyObject *__pyx_sq_item_9pyscipopt_4scip_Expr(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static CYTHON_INLINE PyObject *__pyx_nb_add_9pyscipopt_4scip_Expr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_add : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_add); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_add_9pyscipopt_4scip_Expr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_add == &__pyx_nb_add_9pyscipopt_4scip_Expr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_4Expr_11__add__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_add == &__pyx_nb_add_9pyscipopt_4scip_Expr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_right) { + return __pyx_pw_9pyscipopt_4scip_4Expr_27__radd__(right, left); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static CYTHON_INLINE PyObject *__pyx_nb_subtract_9pyscipopt_4scip_Expr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_subtract : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_subtract); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_subtract_9pyscipopt_4scip_Expr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_subtract == &__pyx_nb_subtract_9pyscipopt_4scip_Expr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_4Expr_25__sub__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_subtract == &__pyx_nb_subtract_9pyscipopt_4scip_Expr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_right) { + return __pyx_pw_9pyscipopt_4scip_4Expr_31__rsub__(right, left); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static CYTHON_INLINE PyObject *__pyx_nb_multiply_9pyscipopt_4scip_Expr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_multiply : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_multiply); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_multiply_9pyscipopt_4scip_Expr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_multiply == &__pyx_nb_multiply_9pyscipopt_4scip_Expr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_4Expr_15__mul__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_multiply == &__pyx_nb_multiply_9pyscipopt_4scip_Expr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_right) { + return __pyx_pw_9pyscipopt_4scip_4Expr_29__rmul__(right, left); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static CYTHON_INLINE PyObject *__pyx_nb_power_9pyscipopt_4scip_Expr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right , PyObject* extra_arg) { + ternaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_power : NULL; +#else + slot = (ternaryfunc) PyType_GetSlot(type, Py_nb_power); +#endif + return slot ? slot(left, right , extra_arg) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_power_9pyscipopt_4scip_Expr(PyObject *left, PyObject *right , PyObject* extra_arg) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_power == &__pyx_nb_power_9pyscipopt_4scip_Expr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_4Expr_21__pow__(left, right, extra_arg); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_power == &__pyx_nb_power_9pyscipopt_4scip_Expr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_right) { + return __pyx_nb_power_9pyscipopt_4scip_Expr_maybe_call_slot(__Pyx_PyType_GetSlot(__pyx_ptype_9pyscipopt_4scip_Expr, tp_base, PyTypeObject*), left, right , extra_arg); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static CYTHON_INLINE PyObject *__pyx_nb_true_divide_9pyscipopt_4scip_Expr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_true_divide : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_true_divide); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_true_divide_9pyscipopt_4scip_Expr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_true_divide == &__pyx_nb_true_divide_9pyscipopt_4scip_Expr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_4Expr_17__truediv__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_true_divide == &__pyx_nb_true_divide_9pyscipopt_4scip_Expr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_Expr); + if (maybe_self_is_right) { + return __pyx_pw_9pyscipopt_4scip_4Expr_19__rtruediv__(right, left); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static PyObject *__pyx_getprop_9pyscipopt_4scip_4Expr_terms(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_4Expr_5terms_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_4Expr_terms(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_4Expr_5terms_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_4Expr_5terms_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_4Expr_7__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + PyObject *res = __pyx_pw_9pyscipopt_4scip_4Expr_7__next__(self); + if (!res && !PyErr_Occurred()) { PyErr_SetNone(PyExc_StopIteration); } + return res; +} +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_4Expr_37__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_4Expr_37__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Expr[] = { + {"__next__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_4Expr_7__next__, METH_NOARGS|METH_COEXIST, 0}, + {"__rtruediv__", (PyCFunction)__pyx_pw_9pyscipopt_4scip_4Expr_19__rtruediv__, METH_O|METH_COEXIST, __pyx_doc_9pyscipopt_4scip_4Expr_18__rtruediv__}, + {"__radd__", (PyCFunction)__pyx_pw_9pyscipopt_4scip_4Expr_27__radd__, METH_O|METH_COEXIST, 0}, + {"__rmul__", (PyCFunction)__pyx_pw_9pyscipopt_4scip_4Expr_29__rmul__, METH_O|METH_COEXIST, 0}, + {"__rsub__", (PyCFunction)__pyx_pw_9pyscipopt_4scip_4Expr_31__rsub__, METH_O|METH_COEXIST, 0}, + {"normalize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Expr_35normalize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Expr_34normalize}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_4Expr_37__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"degree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Expr_39degree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Expr_38degree}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Expr_41__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Expr_40__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Expr_43__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Expr_42__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Expr[] = { + {(char *)"terms", __pyx_getprop_9pyscipopt_4scip_4Expr_terms, __pyx_setprop_9pyscipopt_4scip_4Expr_terms, (char *)PyDoc_STR("terms: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Expr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Expr}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_37__repr__}, + {Py_nb_add, (void *)__pyx_nb_add_9pyscipopt_4scip_Expr}, + {Py_nb_subtract, (void *)__pyx_nb_subtract_9pyscipopt_4scip_Expr}, + {Py_nb_multiply, (void *)__pyx_nb_multiply_9pyscipopt_4scip_Expr}, + {Py_nb_power, (void *)__pyx_nb_power_9pyscipopt_4scip_Expr}, + {Py_nb_negative, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_23__neg__}, + {Py_nb_absolute, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_9__abs__}, + {Py_nb_inplace_add, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_13__iadd__}, + {Py_nb_true_divide, (void *)__pyx_nb_true_divide_9pyscipopt_4scip_Expr}, + {Py_sq_item, (void *)__pyx_sq_item_9pyscipopt_4scip_Expr}, + {Py_mp_subscript, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_3__getitem__}, + {Py_tp_doc, (void *)PyDoc_STR("Expr(terms=None)")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Expr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Expr}, + {Py_tp_richcompare, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_33__richcmp__}, + {Py_tp_iter, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_5__iter__}, + {Py_tp_iternext, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_7__next__}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Expr}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Expr}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_4Expr_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Expr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Expr_spec = { + "pyscipopt.scip.Expr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Expr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Expr_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_Expr = { + __pyx_nb_add_9pyscipopt_4scip_Expr, /*nb_add*/ + __pyx_nb_subtract_9pyscipopt_4scip_Expr, /*nb_subtract*/ + __pyx_nb_multiply_9pyscipopt_4scip_Expr, /*nb_multiply*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_divide*/ + #endif + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + __pyx_nb_power_9pyscipopt_4scip_Expr, /*nb_power*/ + __pyx_pw_9pyscipopt_4scip_4Expr_23__neg__, /*nb_negative*/ + 0, /*nb_positive*/ + __pyx_pw_9pyscipopt_4scip_4Expr_9__abs__, /*nb_absolute*/ + 0, /*nb_bool*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_coerce*/ + #endif + 0, /*nb_int*/ + #if PY_MAJOR_VERSION < 3 + 0, /*nb_long*/ + #else + 0, /*reserved*/ + #endif + 0, /*nb_float*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_oct*/ + #endif + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_hex*/ + #endif + __pyx_pw_9pyscipopt_4scip_4Expr_13__iadd__, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_inplace_divide*/ + #endif + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + __pyx_nb_true_divide_9pyscipopt_4scip_Expr, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_matrix_multiply*/ + #endif + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_inplace_matrix_multiply*/ + #endif +}; + +static PySequenceMethods __pyx_tp_as_sequence_Expr = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_9pyscipopt_4scip_Expr, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_Expr = { + 0, /*mp_length*/ + __pyx_pw_9pyscipopt_4scip_4Expr_3__getitem__, /*mp_subscript*/ + 0, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Expr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Expr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Expr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Expr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_4Expr_37__repr__, /*tp_repr*/ + &__pyx_tp_as_number_Expr, /*tp_as_number*/ + &__pyx_tp_as_sequence_Expr, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_Expr, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Expr(terms=None)"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Expr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Expr, /*tp_clear*/ + __pyx_pw_9pyscipopt_4scip_4Expr_33__richcmp__, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + __pyx_pw_9pyscipopt_4scip_4Expr_5__iter__, /*tp_iter*/ + __pyx_pw_9pyscipopt_4scip_4Expr_7__next__, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Expr, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Expr, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_4Expr_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Expr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_Event __pyx_vtable_9pyscipopt_4scip_Event; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Event(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Event *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Event *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_Event; + p->data = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Event(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Event *p = (struct __pyx_obj_9pyscipopt_4scip_Event *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Event) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->data); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Event(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Event *p = (struct __pyx_obj_9pyscipopt_4scip_Event *)o; + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Event(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Event *p = (struct __pyx_obj_9pyscipopt_4scip_Event *)o; + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_9pyscipopt_4scip_Event(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_9pyscipopt_4scip_5Event_23__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_9pyscipopt_4scip_5Event_23__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_5Event_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_5Event_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_5Event_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_5Event_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_5Event_4data_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_5Event_7__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_5Event_7__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Event[] = { + {"getType", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_1getType, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_getType}, + {"getName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_3getName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_2getName}, + {"_getEventNames", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_5_getEventNames, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_4_getEventNames}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_5Event_7__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"getNewBound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_11getNewBound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_10getNewBound}, + {"getOldBound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_13getOldBound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_12getOldBound}, + {"getVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_15getVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_14getVar}, + {"getNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_17getNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_16getNode}, + {"getRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_19getRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_18getRow}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_25__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_24__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Event_27__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Event_26__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Event[] = { + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_5Event_data, __pyx_setprop_9pyscipopt_4scip_5Event_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Event_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Event}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_5Event_7__repr__}, + {Py_tp_hash, (void *)__pyx_pw_9pyscipopt_4scip_5Event_21__hash__}, + {Py_tp_str, (void *)__pyx_pw_9pyscipopt_4scip_5Event_9__str__}, + {Py_tp_doc, (void *)PyDoc_STR("Base class holding a pointer to corresponding SCIP_EVENT")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Event}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Event}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_9pyscipopt_4scip_Event}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Event}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Event}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Event}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Event_spec = { + "pyscipopt.scip.Event", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Event), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Event_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Event = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Event", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Event), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Event, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_5Event_7__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + __pyx_pw_9pyscipopt_4scip_5Event_21__hash__, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_pw_9pyscipopt_4scip_5Event_9__str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Base class holding a pointer to corresponding SCIP_EVENT"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Event, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Event, /*tp_clear*/ + __pyx_tp_richcompare_9pyscipopt_4scip_Event, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Event, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Event, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Event, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_Column __pyx_vtable_9pyscipopt_4scip_Column; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Column(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Column *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Column *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_Column; + p->data = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Column(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Column *p = (struct __pyx_obj_9pyscipopt_4scip_Column *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Column) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->data); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Column(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Column *p = (struct __pyx_obj_9pyscipopt_4scip_Column *)o; + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Column(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Column *p = (struct __pyx_obj_9pyscipopt_4scip_Column *)o; + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_9pyscipopt_4scip_Column(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_9pyscipopt_4scip_6Column_19__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_9pyscipopt_4scip_6Column_19__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_6Column_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_6Column_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_6Column_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_6Column_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_6Column_4data_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Column[] = { + {"getLPPos", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_1getLPPos, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_getLPPos}, + {"getBasisStatus", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_3getBasisStatus, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_2getBasisStatus}, + {"isIntegral", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_5isIntegral, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_4isIntegral}, + {"getVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_7getVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_6getVar}, + {"getPrimsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_9getPrimsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_8getPrimsol}, + {"getLb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_11getLb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_10getLb}, + {"getUb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_13getUb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_12getUb}, + {"getObjCoeff", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_15getObjCoeff, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_14getObjCoeff}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_21__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_20__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Column_23__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Column_22__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Column[] = { + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_6Column_data, __pyx_setprop_9pyscipopt_4scip_6Column_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Column_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Column}, + {Py_tp_hash, (void *)__pyx_pw_9pyscipopt_4scip_6Column_17__hash__}, + {Py_tp_doc, (void *)PyDoc_STR("Base class holding a pointer to corresponding SCIP_COL")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Column}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Column}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_9pyscipopt_4scip_Column}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Column}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Column}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Column}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Column_spec = { + "pyscipopt.scip.Column", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Column), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Column_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Column = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Column", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Column), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Column, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + __pyx_pw_9pyscipopt_4scip_6Column_17__hash__, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Base class holding a pointer to corresponding SCIP_COL"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Column, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Column, /*tp_clear*/ + __pyx_tp_richcompare_9pyscipopt_4scip_Column, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Column, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Column, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Column, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_Row __pyx_vtable_9pyscipopt_4scip_Row; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Row(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Row *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Row *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_Row; + p->data = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Row(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Row *p = (struct __pyx_obj_9pyscipopt_4scip_Row *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Row) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->data); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Row(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Row *p = (struct __pyx_obj_9pyscipopt_4scip_Row *)o; + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Row(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Row *p = (struct __pyx_obj_9pyscipopt_4scip_Row *)o; + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_9pyscipopt_4scip_Row(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_9pyscipopt_4scip_3Row_37__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_9pyscipopt_4scip_3Row_37__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_3Row_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_3Row_4name_1__get__(o); +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_3Row_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_3Row_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_3Row_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_3Row_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_3Row_4data_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Row[] = { + {"getLhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_1getLhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_getLhs}, + {"getRhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_3getRhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_2getRhs}, + {"getConstant", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_5getConstant, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_4getConstant}, + {"getLPPos", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_7getLPPos, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_6getLPPos}, + {"getBasisStatus", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_9getBasisStatus, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_8getBasisStatus}, + {"isIntegral", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_11isIntegral, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_10isIntegral}, + {"isLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_13isLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_12isLocal}, + {"isModifiable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_15isModifiable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_14isModifiable}, + {"isRemovable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_17isRemovable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_16isRemovable}, + {"isInGlobalCutpool", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_19isInGlobalCutpool, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_18isInGlobalCutpool}, + {"getOrigintype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_21getOrigintype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_20getOrigintype}, + {"getConsOriginConshdlrtype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_23getConsOriginConshdlrtype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_22getConsOriginConshdlrtype}, + {"getNNonz", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_25getNNonz, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_24getNNonz}, + {"getNLPNonz", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_27getNLPNonz, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_26getNLPNonz}, + {"getCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_29getCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_28getCols}, + {"getVals", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_31getVals, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_30getVals}, + {"getNorm", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_33getNorm, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_32getNorm}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_39__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_38__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_3Row_41__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_3Row_40__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Row[] = { + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_3Row_name, 0, (char *)0, 0}, + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_3Row_data, __pyx_setprop_9pyscipopt_4scip_3Row_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Row_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Row}, + {Py_tp_hash, (void *)__pyx_pw_9pyscipopt_4scip_3Row_35__hash__}, + {Py_tp_doc, (void *)PyDoc_STR("Base class holding a pointer to corresponding SCIP_ROW")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Row}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Row}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_9pyscipopt_4scip_Row}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Row}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Row}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Row}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Row_spec = { + "pyscipopt.scip.Row", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Row), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Row_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Row = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Row", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Row), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Row, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + __pyx_pw_9pyscipopt_4scip_3Row_35__hash__, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Base class holding a pointer to corresponding SCIP_ROW"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Row, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Row, /*tp_clear*/ + __pyx_tp_richcompare_9pyscipopt_4scip_Row, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Row, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Row, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Row, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_NLRow __pyx_vtable_9pyscipopt_4scip_NLRow; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_NLRow(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_NLRow *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_NLRow *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_NLRow; + p->data = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_NLRow(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_NLRow *p = (struct __pyx_obj_9pyscipopt_4scip_NLRow *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_NLRow) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->data); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_NLRow(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_NLRow *p = (struct __pyx_obj_9pyscipopt_4scip_NLRow *)o; + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_NLRow(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_NLRow *p = (struct __pyx_obj_9pyscipopt_4scip_NLRow *)o; + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_9pyscipopt_4scip_NLRow(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_9pyscipopt_4scip_5NLRow_13__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_9pyscipopt_4scip_5NLRow_13__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_5NLRow_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_5NLRow_4name_1__get__(o); +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_5NLRow_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_5NLRow_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_5NLRow_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_5NLRow_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_5NLRow_4data_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_NLRow[] = { + {"getConstant", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_1getConstant, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_getConstant}, + {"getLinearTerms", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_3getLinearTerms, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_2getLinearTerms}, + {"getLhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_5getLhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_4getLhs}, + {"getRhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_7getRhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_6getRhs}, + {"getDualsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_9getDualsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_8getDualsol}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_14__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5NLRow_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5NLRow_16__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_NLRow[] = { + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_5NLRow_name, 0, (char *)0, 0}, + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_5NLRow_data, __pyx_setprop_9pyscipopt_4scip_5NLRow_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_NLRow_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_NLRow}, + {Py_tp_hash, (void *)__pyx_pw_9pyscipopt_4scip_5NLRow_11__hash__}, + {Py_tp_doc, (void *)PyDoc_STR("Base class holding a pointer to corresponding SCIP_NLROW")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_NLRow}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_NLRow}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_9pyscipopt_4scip_NLRow}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_NLRow}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_NLRow}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_NLRow}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_NLRow_spec = { + "pyscipopt.scip.NLRow", + sizeof(struct __pyx_obj_9pyscipopt_4scip_NLRow), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_NLRow_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_NLRow = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""NLRow", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_NLRow), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_NLRow, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + __pyx_pw_9pyscipopt_4scip_5NLRow_11__hash__, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Base class holding a pointer to corresponding SCIP_NLROW"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_NLRow, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_NLRow, /*tp_clear*/ + __pyx_tp_richcompare_9pyscipopt_4scip_NLRow, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_NLRow, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_NLRow, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_NLRow, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_Solution __pyx_vtable_9pyscipopt_4scip_Solution; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Solution(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Solution *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_Solution; + p->data = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Solution(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Solution *p = (struct __pyx_obj_9pyscipopt_4scip_Solution *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Solution) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->data); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Solution(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Solution *p = (struct __pyx_obj_9pyscipopt_4scip_Solution *)o; + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Solution(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Solution *p = (struct __pyx_obj_9pyscipopt_4scip_Solution *)o; + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +static PyObject *__pyx_sq_item_9pyscipopt_4scip_Solution(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_9pyscipopt_4scip_Solution(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8Solution_7__setitem__(o, i, v); + } + else { + __Pyx_TypeName o_type_name; + o_type_name = __Pyx_PyType_GetName(Py_TYPE(o)); + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); + __Pyx_DECREF_TypeName(o_type_name); + return -1; + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8Solution_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8Solution_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8Solution_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8Solution_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8Solution_4data_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8Solution_9__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_8Solution_9__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Solution[] = { + {"_evaluate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Solution_5_evaluate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Solution_4_evaluate}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8Solution_9__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"_checkStage", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Solution_11_checkStage, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Solution_10_checkStage}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Solution_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Solution_12__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Solution_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Solution_14__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Solution[] = { + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_8Solution_data, __pyx_setprop_9pyscipopt_4scip_8Solution_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Solution_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Solution}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_8Solution_9__repr__}, + {Py_sq_item, (void *)__pyx_sq_item_9pyscipopt_4scip_Solution}, + {Py_mp_subscript, (void *)__pyx_pw_9pyscipopt_4scip_8Solution_3__getitem__}, + {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_9pyscipopt_4scip_Solution}, + {Py_tp_doc, (void *)PyDoc_STR("Solution(raise_error=False)\nBase class holding a pointer to corresponding SCIP_SOL")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Solution}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Solution}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Solution}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Solution}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_8Solution_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Solution}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Solution_spec = { + "pyscipopt.scip.Solution", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Solution), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Solution_slots, +}; +#else + +static PySequenceMethods __pyx_tp_as_sequence_Solution = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_9pyscipopt_4scip_Solution, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_Solution = { + 0, /*mp_length*/ + __pyx_pw_9pyscipopt_4scip_8Solution_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_9pyscipopt_4scip_Solution, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Solution = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Solution", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Solution), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Solution, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_8Solution_9__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_Solution, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_Solution, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Solution(raise_error=False)\nBase class holding a pointer to corresponding SCIP_SOL"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Solution, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Solution, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Solution, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Solution, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_8Solution_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Solution, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_DomainChanges __pyx_vtable_9pyscipopt_4scip_DomainChanges; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_DomainChanges(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_DomainChanges *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_DomainChanges *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_DomainChanges; + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_DomainChanges(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_DomainChanges) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_DomainChanges[] = { + {"getBoundchgs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13DomainChanges_1getBoundchgs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13DomainChanges_getBoundchgs}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13DomainChanges_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13DomainChanges_2__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13DomainChanges_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13DomainChanges_4__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_DomainChanges_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_DomainChanges}, + {Py_tp_doc, (void *)PyDoc_STR("Set of domain changes.")}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_DomainChanges}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_DomainChanges}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_DomainChanges_spec = { + "pyscipopt.scip.DomainChanges", + sizeof(struct __pyx_obj_9pyscipopt_4scip_DomainChanges), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_DomainChanges_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_DomainChanges = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""DomainChanges", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_DomainChanges), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_DomainChanges, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + PyDoc_STR("Set of domain changes."), /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_DomainChanges, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_DomainChanges, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_BoundChange __pyx_vtable_9pyscipopt_4scip_BoundChange; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_BoundChange(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_BoundChange *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_BoundChange *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_BoundChange; + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_BoundChange(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_BoundChange) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_11BoundChange_11__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_11BoundChange_11__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_BoundChange[] = { + {"getNewBound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_1getNewBound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_getNewBound}, + {"getVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_3getVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_2getVar}, + {"getBoundchgtype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_5getBoundchgtype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_4getBoundchgtype}, + {"getBoundtype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_7getBoundtype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_6getBoundtype}, + {"isRedundant", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_9isRedundant, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_8isRedundant}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_11BoundChange_11__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_12__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_11BoundChange_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_11BoundChange_14__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_BoundChange_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_BoundChange}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_11BoundChange_11__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("Bound change.")}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_BoundChange}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_BoundChange}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_BoundChange_spec = { + "pyscipopt.scip.BoundChange", + sizeof(struct __pyx_obj_9pyscipopt_4scip_BoundChange), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_BoundChange_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_BoundChange = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""BoundChange", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_BoundChange), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_BoundChange, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_11BoundChange_11__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + PyDoc_STR("Bound change."), /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_BoundChange, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_BoundChange, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_Node __pyx_vtable_9pyscipopt_4scip_Node; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Node(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Node *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Node *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_Node; + p->data = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Node(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Node *p = (struct __pyx_obj_9pyscipopt_4scip_Node *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Node) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->data); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Node(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Node *p = (struct __pyx_obj_9pyscipopt_4scip_Node *)o; + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Node(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Node *p = (struct __pyx_obj_9pyscipopt_4scip_Node *)o; + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_9pyscipopt_4scip_Node(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_9pyscipopt_4scip_4Node_31__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_9pyscipopt_4scip_4Node_31__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_4Node_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_4Node_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_4Node_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_4Node_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_4Node_4data_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Node[] = { + {"getParent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_1getParent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_getParent}, + {"getNumber", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_3getNumber, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_2getNumber}, + {"getDepth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_5getDepth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_4getDepth}, + {"getType", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_7getType, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_6getType}, + {"getLowerbound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_9getLowerbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_8getLowerbound}, + {"getEstimate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_11getEstimate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_10getEstimate}, + {"getAddedConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_13getAddedConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_12getAddedConss}, + {"getNAddedConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_15getNAddedConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_14getNAddedConss}, + {"isActive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_17isActive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_16isActive}, + {"isPropagatedAgain", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_19isPropagatedAgain, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_18isPropagatedAgain}, + {"getNParentBranchings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_21getNParentBranchings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_20getNParentBranchings}, + {"getParentBranchings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_23getParentBranchings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_22getParentBranchings}, + {"getNDomchg", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_25getNDomchg, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_24getNDomchg}, + {"getDomchg", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_27getDomchg, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_26getDomchg}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_33__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_32__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Node_35__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Node_34__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Node[] = { + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_4Node_data, __pyx_setprop_9pyscipopt_4scip_4Node_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Node_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Node}, + {Py_tp_hash, (void *)__pyx_pw_9pyscipopt_4scip_4Node_29__hash__}, + {Py_tp_doc, (void *)PyDoc_STR("Base class holding a pointer to corresponding SCIP_NODE")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Node}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Node}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_9pyscipopt_4scip_Node}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Node}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Node}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Node}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Node_spec = { + "pyscipopt.scip.Node", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Node), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Node_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Node = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Node", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Node), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Node, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + __pyx_pw_9pyscipopt_4scip_4Node_29__hash__, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Base class holding a pointer to corresponding SCIP_NODE"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Node, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Node, /*tp_clear*/ + __pyx_tp_richcompare_9pyscipopt_4scip_Node, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Node, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Node, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Node, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_Variable __pyx_vtable_9pyscipopt_4scip_Variable; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Variable(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Variable *p; + PyObject *o = __pyx_tp_new_9pyscipopt_4scip_Expr(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pyscipopt_4scip_Variable *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_Variable; + p->data = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Variable(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Variable *p = (struct __pyx_obj_9pyscipopt_4scip_Variable *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Variable) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->data); + PyObject_GC_Track(o); + __pyx_tp_dealloc_9pyscipopt_4scip_Expr(o); +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Variable(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Variable *p = (struct __pyx_obj_9pyscipopt_4scip_Variable *)o; + e = __pyx_tp_traverse_9pyscipopt_4scip_Expr(o, v, a); if (e) return e; + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Variable(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Variable *p = (struct __pyx_obj_9pyscipopt_4scip_Variable *)o; + __pyx_tp_clear_9pyscipopt_4scip_Expr(o); + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8Variable_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8Variable_4name_1__get__(o); +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8Variable_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8Variable_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8Variable_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8Variable_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8Variable_4data_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8Variable_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_8Variable_3__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Variable[] = { + {"ptr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_1ptr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_ptr}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8Variable_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"vtype", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_5vtype, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_4vtype}, + {"isOriginal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_7isOriginal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_6isOriginal}, + {"isInLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_9isInLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_8isInLP}, + {"getIndex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_11getIndex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_10getIndex}, + {"getCol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_13getCol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_12getCol}, + {"getLbOriginal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_15getLbOriginal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_14getLbOriginal}, + {"getUbOriginal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_17getUbOriginal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_16getUbOriginal}, + {"getLbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_19getLbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_18getLbGlobal}, + {"getUbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_21getUbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_20getUbGlobal}, + {"getLbLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_23getLbLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_22getLbLocal}, + {"getUbLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_25getUbLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_24getUbLocal}, + {"getObj", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_27getObj, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_26getObj}, + {"getLPSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_29getLPSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_28getLPSol}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_31__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_30__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Variable_33__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Variable_32__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Variable[] = { + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_8Variable_name, 0, (char *)0, 0}, + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_8Variable_data, __pyx_setprop_9pyscipopt_4scip_8Variable_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Variable_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Variable}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_8Variable_3__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("Is a linear expression and has SCIP_VAR*")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Variable}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Variable}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Variable}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Variable}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Variable}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Variable_spec = { + "pyscipopt.scip.Variable", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Variable), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Variable_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Variable = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Variable", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Variable), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Variable, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_8Variable_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Is a linear expression and has SCIP_VAR*"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Variable, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Variable, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + #if CYTHON_COMPILING_IN_PYPY || 0 + __pyx_pw_9pyscipopt_4scip_4Expr_5__iter__, /*tp_iter*/ + #else + 0, /*tp_iter*/ + #endif + #if CYTHON_COMPILING_IN_PYPY || 0 + __pyx_pw_9pyscipopt_4scip_4Expr_7__next__, /*tp_iternext*/ + #else + 0, /*tp_iternext*/ + #endif + __pyx_methods_9pyscipopt_4scip_Variable, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Variable, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + #if CYTHON_COMPILING_IN_PYPY || 0 + __pyx_pw_9pyscipopt_4scip_4Expr_1__init__, /*tp_init*/ + #else + 0, /*tp_init*/ + #endif + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Variable, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_Constraint __pyx_vtable_9pyscipopt_4scip_Constraint; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Constraint(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Constraint *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_Constraint; + p->data = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Constraint(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Constraint *p = (struct __pyx_obj_9pyscipopt_4scip_Constraint *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Constraint) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->data); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Constraint(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Constraint *p = (struct __pyx_obj_9pyscipopt_4scip_Constraint *)o; + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Constraint(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Constraint *p = (struct __pyx_obj_9pyscipopt_4scip_Constraint *)o; + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_9pyscipopt_4scip_Constraint(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_9pyscipopt_4scip_10Constraint_35__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_9pyscipopt_4scip_10Constraint_35__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_10Constraint_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_10Constraint_4name_1__get__(o); +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_10Constraint_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_10Constraint_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_10Constraint_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_10Constraint_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_10Constraint_4data_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_10Constraint_1__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_10Constraint_1__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Constraint[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_10Constraint_1__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"isOriginal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_3isOriginal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_2isOriginal}, + {"isInitial", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_5isInitial, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_4isInitial}, + {"isSeparated", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_7isSeparated, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_6isSeparated}, + {"isEnforced", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_9isEnforced, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_8isEnforced}, + {"isChecked", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_11isChecked, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_10isChecked}, + {"isPropagated", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_13isPropagated, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_12isPropagated}, + {"isLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_15isLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_14isLocal}, + {"isModifiable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_17isModifiable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_16isModifiable}, + {"isDynamic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_19isDynamic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_18isDynamic}, + {"isRemovable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_21isRemovable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_20isRemovable}, + {"isStickingAtNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_23isStickingAtNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_22isStickingAtNode}, + {"isActive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_25isActive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_24isActive}, + {"isLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_27isLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_26isLinear}, + {"isNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_29isNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_28isNonlinear}, + {"getConshdlrName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_31getConshdlrName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_30getConshdlrName}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_37__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_36__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Constraint_39__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Constraint_38__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Constraint[] = { + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_10Constraint_name, 0, (char *)0, 0}, + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_10Constraint_data, __pyx_setprop_9pyscipopt_4scip_10Constraint_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Constraint_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Constraint}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_10Constraint_1__repr__}, + {Py_tp_hash, (void *)__pyx_pw_9pyscipopt_4scip_10Constraint_33__hash__}, + {Py_tp_doc, (void *)PyDoc_STR("Base class holding a pointer to corresponding SCIP_CONS")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Constraint}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Constraint}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_9pyscipopt_4scip_Constraint}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Constraint}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Constraint}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Constraint}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Constraint_spec = { + "pyscipopt.scip.Constraint", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Constraint), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Constraint_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Constraint = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Constraint", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Constraint), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Constraint, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_10Constraint_1__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + __pyx_pw_9pyscipopt_4scip_10Constraint_33__hash__, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Base class holding a pointer to corresponding SCIP_CONS"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Constraint, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Constraint, /*tp_clear*/ + __pyx_tp_richcompare_9pyscipopt_4scip_Constraint, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Constraint, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Constraint, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Constraint, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_9pyscipopt_4scip_Model __pyx_vtable_9pyscipopt_4scip_Model; + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Model(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Model *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Model *)o); + p->__pyx_vtab = __pyx_vtabptr_9pyscipopt_4scip_Model; + p->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None); Py_INCREF(Py_None); + p->data = Py_None; Py_INCREF(Py_None); + p->_modelvars = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Model(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Model *p = (struct __pyx_obj_9pyscipopt_4scip_Model *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Model) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + if (p->__weakref__) PyObject_ClearWeakRefs(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_pw_9pyscipopt_4scip_5Model_3__dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->_bestSol); + Py_CLEAR(p->data); + Py_CLEAR(p->_modelvars); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Model(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Model *p = (struct __pyx_obj_9pyscipopt_4scip_Model *)o; + if (p->_bestSol) { + e = (*v)(((PyObject *)p->_bestSol), a); if (e) return e; + } + if (p->data) { + e = (*v)(p->data, a); if (e) return e; + } + if (p->_modelvars) { + e = (*v)(p->_modelvars, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Model(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Model *p = (struct __pyx_obj_9pyscipopt_4scip_Model *)o; + tmp = ((PyObject*)p->_bestSol); + p->_bestSol = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->data); + p->data = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_modelvars); + p->_modelvars = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_tp_richcompare_9pyscipopt_4scip_Model(PyObject *o1, PyObject *o2, int op) { + switch (op) { + case Py_EQ: { + return __pyx_pw_9pyscipopt_4scip_5Model_7__eq__(o1, o2); + } + case Py_NE: { + PyObject *ret; + ret = __pyx_pw_9pyscipopt_4scip_5Model_7__eq__(o1, o2); + if (likely(ret && ret != Py_NotImplemented)) { + int b = __Pyx_PyObject_IsTrue(ret); + Py_DECREF(ret); + if (unlikely(b < 0)) return NULL; + ret = (b) ? Py_False : Py_True; + Py_INCREF(ret); + } + return ret; + } + default: { + return __Pyx_NewRef(Py_NotImplemented); + } + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_5Model__freescip(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_5Model_9_freescip_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_5Model__freescip(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_5Model_9_freescip_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_5Model_data(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_5Model_4data_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_5Model_data(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_5Model_4data_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_5Model_4data_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Model[] = { + {"from_ptr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_9from_ptr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_8from_ptr}, + {"to_ptr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_11to_ptr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_10to_ptr}, + {"includeDefaultPlugins", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_13includeDefaultPlugins, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_12includeDefaultPlugins}, + {"createProbBasic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_15createProbBasic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_14createProbBasic}, + {"freeProb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_17freeProb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_16freeProb}, + {"freeTransform", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_19freeTransform, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_18freeTransform}, + {"version", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_21version, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_20version}, + {"printVersion", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_23printVersion, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_22printVersion}, + {"printExternalCodeVersions", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_25printExternalCodeVersions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_24printExternalCodeVersions}, + {"getProbName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_27getProbName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_26getProbName}, + {"getTotalTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_29getTotalTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_28getTotalTime}, + {"getSolvingTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_31getSolvingTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_30getSolvingTime}, + {"getReadingTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_33getReadingTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_32getReadingTime}, + {"getPresolvingTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_35getPresolvingTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_34getPresolvingTime}, + {"getNLPIterations", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_37getNLPIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_36getNLPIterations}, + {"getNNodes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_39getNNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_38getNNodes}, + {"getNTotalNodes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_41getNTotalNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_40getNTotalNodes}, + {"getNFeasibleLeaves", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_43getNFeasibleLeaves, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_42getNFeasibleLeaves}, + {"getNInfeasibleLeaves", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_45getNInfeasibleLeaves, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_44getNInfeasibleLeaves}, + {"getNLeaves", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_47getNLeaves, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_46getNLeaves}, + {"getNChildren", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_49getNChildren, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_48getNChildren}, + {"getNSiblings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_51getNSiblings, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_50getNSiblings}, + {"getCurrentNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_53getCurrentNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_52getCurrentNode}, + {"getGap", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_55getGap, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_54getGap}, + {"getDepth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_57getDepth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_56getDepth}, + {"infinity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_59infinity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_58infinity}, + {"epsilon", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_61epsilon, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_60epsilon}, + {"feastol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_63feastol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_62feastol}, + {"feasFrac", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_65feasFrac, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_64feasFrac}, + {"frac", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_67frac, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_66frac}, + {"isZero", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_69isZero, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_68isZero}, + {"isFeasZero", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_71isFeasZero, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_70isFeasZero}, + {"isInfinity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_73isInfinity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_72isInfinity}, + {"isFeasNegative", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_75isFeasNegative, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_74isFeasNegative}, + {"isFeasIntegral", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_77isFeasIntegral, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_76isFeasIntegral}, + {"isEQ", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_79isEQ, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_78isEQ}, + {"isFeasEQ", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_81isFeasEQ, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_80isFeasEQ}, + {"isLE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_83isLE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_82isLE}, + {"isLT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_85isLT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_84isLT}, + {"isGE", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_87isGE, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_86isGE}, + {"isGT", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_89isGT, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_88isGT}, + {"getCondition", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_91getCondition, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_90getCondition}, + {"enableReoptimization", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_93enableReoptimization, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_92enableReoptimization}, + {"lpiGetIterations", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_95lpiGetIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_94lpiGetIterations}, + {"setMinimize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_97setMinimize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_96setMinimize}, + {"setMaximize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_99setMaximize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_98setMaximize}, + {"setObjlimit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_101setObjlimit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_100setObjlimit}, + {"getObjlimit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_103getObjlimit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_102getObjlimit}, + {"setObjective", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_105setObjective, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_104setObjective}, + {"getObjective", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_107getObjective, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_106getObjective}, + {"addObjoffset", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_109addObjoffset, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_108addObjoffset}, + {"getObjoffset", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_111getObjoffset, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_110getObjoffset}, + {"setObjIntegral", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_113setObjIntegral, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_112setObjIntegral}, + {"getLocalEstimate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_115getLocalEstimate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_114getLocalEstimate}, + {"setPresolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_117setPresolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_116setPresolve}, + {"setProbName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_119setProbName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_118setProbName}, + {"setSeparating", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_121setSeparating, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_120setSeparating}, + {"setHeuristics", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_123setHeuristics, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_122setHeuristics}, + {"disablePropagation", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_125disablePropagation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_124disablePropagation}, + {"writeProblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_127writeProblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_126writeProblem}, + {"addVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_129addVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_128addVar}, + {"getTransformedVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_131getTransformedVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_130getTransformedVar}, + {"addVarLocks", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_133addVarLocks, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_132addVarLocks}, + {"fixVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_135fixVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_134fixVar}, + {"delVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_137delVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_136delVar}, + {"tightenVarLb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_139tightenVarLb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_138tightenVarLb}, + {"tightenVarUb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_141tightenVarUb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_140tightenVarUb}, + {"tightenVarUbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_143tightenVarUbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_142tightenVarUbGlobal}, + {"tightenVarLbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_145tightenVarLbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_144tightenVarLbGlobal}, + {"chgVarLb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_147chgVarLb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_146chgVarLb}, + {"chgVarUb", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_149chgVarUb, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_148chgVarUb}, + {"chgVarLbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_151chgVarLbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_150chgVarLbGlobal}, + {"chgVarUbGlobal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_153chgVarUbGlobal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_152chgVarUbGlobal}, + {"chgVarLbNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_155chgVarLbNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_154chgVarLbNode}, + {"chgVarUbNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_157chgVarUbNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_156chgVarUbNode}, + {"chgVarType", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_159chgVarType, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_158chgVarType}, + {"getVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_161getVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_160getVars}, + {"getNVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_163getNVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_162getNVars}, + {"getNIntVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_165getNIntVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_164getNIntVars}, + {"getNBinVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_167getNBinVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_166getNBinVars}, + {"getVarDict", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_169getVarDict, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_168getVarDict}, + {"updateNodeLowerbound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_171updateNodeLowerbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_170updateNodeLowerbound}, + {"relax", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_173relax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_172relax}, + {"getBestChild", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_175getBestChild, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_174getBestChild}, + {"getBestSibling", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_177getBestSibling, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_176getBestSibling}, + {"getBestLeaf", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_179getBestLeaf, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_178getBestLeaf}, + {"getBestNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_181getBestNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_180getBestNode}, + {"getBestboundNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_183getBestboundNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_182getBestboundNode}, + {"getOpenNodes", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_185getOpenNodes, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_184getOpenNodes}, + {"repropagateNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_187repropagateNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_186repropagateNode}, + {"getLPSolstat", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_189getLPSolstat, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_188getLPSolstat}, + {"constructLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_191constructLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_190constructLP}, + {"getLPObjVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_193getLPObjVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_192getLPObjVal}, + {"getLPColsData", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_195getLPColsData, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_194getLPColsData}, + {"getLPRowsData", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_197getLPRowsData, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_196getLPRowsData}, + {"getNLPRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_199getNLPRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_198getNLPRows}, + {"getNLPCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_201getNLPCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_200getNLPCols}, + {"getLPBasisInd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_203getLPBasisInd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_202getLPBasisInd}, + {"getLPBInvRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_205getLPBInvRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_204getLPBInvRow}, + {"getLPBInvARow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_207getLPBInvARow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_206getLPBInvARow}, + {"isLPSolBasic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_209isLPSolBasic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_208isLPSolBasic}, + {"createEmptyRowSepa", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_211createEmptyRowSepa, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_210createEmptyRowSepa}, + {"createEmptyRowUnspec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_213createEmptyRowUnspec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_212createEmptyRowUnspec}, + {"getRowActivity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_215getRowActivity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_214getRowActivity}, + {"getRowLPActivity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_217getRowLPActivity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_216getRowLPActivity}, + {"releaseRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_219releaseRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_218releaseRow}, + {"cacheRowExtensions", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_221cacheRowExtensions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_220cacheRowExtensions}, + {"flushRowExtensions", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_223flushRowExtensions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_222flushRowExtensions}, + {"addVarToRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_225addVarToRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_224addVarToRow}, + {"printRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_227printRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_226printRow}, + {"getRowNumIntCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_229getRowNumIntCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_228getRowNumIntCols}, + {"getRowObjParallelism", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_231getRowObjParallelism, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_230getRowObjParallelism}, + {"getRowParallelism", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_233getRowParallelism, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_232getRowParallelism}, + {"getRowDualSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_235getRowDualSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_234getRowDualSol}, + {"addPoolCut", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_237addPoolCut, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_236addPoolCut}, + {"getCutEfficacy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_239getCutEfficacy, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_238getCutEfficacy}, + {"isCutEfficacious", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_241isCutEfficacious, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_240isCutEfficacious}, + {"getCutLPSolCutoffDistance", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_243getCutLPSolCutoffDistance, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_242getCutLPSolCutoffDistance}, + {"addCut", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_245addCut, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_244addCut}, + {"getNCuts", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_247getNCuts, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_246getNCuts}, + {"getNCutsApplied", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_249getNCutsApplied, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_248getNCutsApplied}, + {"getNSepaRounds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_251getNSepaRounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_250getNSepaRounds}, + {"separateSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_253separateSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_252separateSol}, + {"_createConsLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_255_createConsLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_254_createConsLinear}, + {"_createConsQuadratic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_257_createConsQuadratic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_256_createConsQuadratic}, + {"_createConsNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_259_createConsNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_258_createConsNonlinear}, + {"_createConsGenNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_261_createConsGenNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_260_createConsGenNonlinear}, + {"createConsFromExpr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_263createConsFromExpr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_262createConsFromExpr}, + {"addCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_265addCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_264addCons}, + {"addConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_267addConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_266addConss}, + {"addConsDisjunction", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_269addConsDisjunction, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_268addConsDisjunction}, + {"addConsElemDisjunction", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_271addConsElemDisjunction, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_270addConsElemDisjunction}, + {"getConsNVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_273getConsNVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_272getConsNVars}, + {"getConsVars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_275getConsVars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_274getConsVars}, + {"printCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_277printCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_276printCons}, + {"addExprNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_279addExprNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_278addExprNonlinear}, + {"addConsCoeff", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_281addConsCoeff, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_280addConsCoeff}, + {"addConsNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_283addConsNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_282addConsNode}, + {"addConsLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_285addConsLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_284addConsLocal}, + {"addConsSOS1", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_287addConsSOS1, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_286addConsSOS1}, + {"addConsSOS2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_289addConsSOS2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_288addConsSOS2}, + {"addConsAnd", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_291addConsAnd, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_290addConsAnd}, + {"addConsOr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_293addConsOr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_292addConsOr}, + {"addConsXor", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_295addConsXor, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_294addConsXor}, + {"addConsCardinality", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_297addConsCardinality, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_296addConsCardinality}, + {"addConsIndicator", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_299addConsIndicator, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_298addConsIndicator}, + {"getSlackVarIndicator", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_301getSlackVarIndicator, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_300getSlackVarIndicator}, + {"addPyCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_303addPyCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_302addPyCons}, + {"addVarSOS1", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_305addVarSOS1, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_304addVarSOS1}, + {"appendVarSOS1", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_307appendVarSOS1, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_306appendVarSOS1}, + {"addVarSOS2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_309addVarSOS2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_308addVarSOS2}, + {"appendVarSOS2", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_311appendVarSOS2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_310appendVarSOS2}, + {"setInitial", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_313setInitial, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_312setInitial}, + {"setRemovable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_315setRemovable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_314setRemovable}, + {"setEnforced", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_317setEnforced, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_316setEnforced}, + {"setCheck", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_319setCheck, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_318setCheck}, + {"chgRhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_321chgRhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_320chgRhs}, + {"chgLhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_323chgLhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_322chgLhs}, + {"getRhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_325getRhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_324getRhs}, + {"getLhs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_327getLhs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_326getLhs}, + {"chgCoefLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_329chgCoefLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_328chgCoefLinear}, + {"delCoefLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_331delCoefLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_330delCoefLinear}, + {"addCoefLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_333addCoefLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_332addCoefLinear}, + {"getActivity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_335getActivity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_334getActivity}, + {"getSlack", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_337getSlack, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_336getSlack}, + {"getTransformedCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_339getTransformedCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_338getTransformedCons}, + {"isNLPConstructed", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_341isNLPConstructed, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_340isNLPConstructed}, + {"getNNlRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_343getNNlRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_342getNNlRows}, + {"getNlRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_345getNlRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_344getNlRows}, + {"getNlRowSolActivity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_347getNlRowSolActivity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_346getNlRowSolActivity}, + {"getNlRowSolFeasibility", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_349getNlRowSolFeasibility, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_348getNlRowSolFeasibility}, + {"getNlRowActivityBounds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_351getNlRowActivityBounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_350getNlRowActivityBounds}, + {"printNlRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_353printNlRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_352printNlRow}, + {"checkQuadraticNonlinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_355checkQuadraticNonlinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_354checkQuadraticNonlinear}, + {"getTermsQuadratic", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_357getTermsQuadratic, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_356getTermsQuadratic}, + {"setRelaxSolVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_359setRelaxSolVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_358setRelaxSolVal}, + {"getConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_361getConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_360getConss}, + {"getNConss", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_363getNConss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_362getNConss}, + {"delCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_365delCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_364delCons}, + {"delConsLocal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_367delConsLocal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_366delConsLocal}, + {"getValsLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_369getValsLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_368getValsLinear}, + {"getRowLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_371getRowLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_370getRowLinear}, + {"getDualsolLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_373getDualsolLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_372getDualsolLinear}, + {"getDualMultiplier", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_375getDualMultiplier, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_374getDualMultiplier}, + {"getDualfarkasLinear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_377getDualfarkasLinear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_376getDualfarkasLinear}, + {"getVarRedcost", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_379getVarRedcost, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_378getVarRedcost}, + {"getDualSolVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_381getDualSolVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_380getDualSolVal}, + {"optimize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_383optimize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_382optimize}, + {"solveConcurrent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_385solveConcurrent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_384solveConcurrent}, + {"presolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_387presolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_386presolve}, + {"initBendersDefault", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_389initBendersDefault, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_388initBendersDefault}, + {"computeBestSolSubproblems", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_391computeBestSolSubproblems, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_390computeBestSolSubproblems}, + {"freeBendersSubproblems", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_393freeBendersSubproblems, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_392freeBendersSubproblems}, + {"updateBendersLowerbounds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_395updateBendersLowerbounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_394updateBendersLowerbounds}, + {"activateBenders", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_397activateBenders, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_396activateBenders}, + {"addBendersSubproblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_399addBendersSubproblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_398addBendersSubproblem}, + {"setBendersSubproblemIsConvex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_401setBendersSubproblemIsConvex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_400setBendersSubproblemIsConvex}, + {"setupBendersSubproblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_403setupBendersSubproblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_402setupBendersSubproblem}, + {"solveBendersSubproblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_405solveBendersSubproblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_404solveBendersSubproblem}, + {"getBendersSubproblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_407getBendersSubproblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_406getBendersSubproblem}, + {"getBendersVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_409getBendersVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_408getBendersVar}, + {"getBendersAuxiliaryVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_411getBendersAuxiliaryVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_410getBendersAuxiliaryVar}, + {"checkBendersSubproblemOptimality", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_413checkBendersSubproblemOptimality, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_412checkBendersSubproblemOptimality}, + {"includeBendersDefaultCuts", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_415includeBendersDefaultCuts, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_414includeBendersDefaultCuts}, + {"includeEventhdlr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_417includeEventhdlr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_416includeEventhdlr}, + {"includePricer", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_419includePricer, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_418includePricer}, + {"includeConshdlr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_421includeConshdlr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_420includeConshdlr}, + {"createCons", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_423createCons, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_422createCons}, + {"includePresol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_425includePresol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_424includePresol}, + {"includeSepa", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_427includeSepa, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_426includeSepa}, + {"includeReader", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_429includeReader, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_428includeReader}, + {"includeProp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_431includeProp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_430includeProp}, + {"includeHeur", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_433includeHeur, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_432includeHeur}, + {"includeRelax", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_435includeRelax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_434includeRelax}, + {"includeCutsel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_437includeCutsel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_436includeCutsel}, + {"includeBranchrule", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_439includeBranchrule, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_438includeBranchrule}, + {"includeNodesel", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_441includeNodesel, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_440includeNodesel}, + {"includeBenders", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_443includeBenders, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_442includeBenders}, + {"includeBenderscut", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_445includeBenderscut, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_444includeBenderscut}, + {"getLPBranchCands", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_447getLPBranchCands, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_446getLPBranchCands}, + {"getPseudoBranchCands", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_449getPseudoBranchCands, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_448getPseudoBranchCands}, + {"branchVar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_451branchVar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_450branchVar}, + {"branchVarVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_453branchVarVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_452branchVarVal}, + {"calcNodeselPriority", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_455calcNodeselPriority, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_454calcNodeselPriority}, + {"calcChildEstimate", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_457calcChildEstimate, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_456calcChildEstimate}, + {"createChild", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_459createChild, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_458createChild}, + {"startDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_461startDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_460startDive}, + {"endDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_463endDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_462endDive}, + {"chgVarObjDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_465chgVarObjDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_464chgVarObjDive}, + {"chgVarLbDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_467chgVarLbDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_466chgVarLbDive}, + {"chgVarUbDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_469chgVarUbDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_468chgVarUbDive}, + {"getVarLbDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_471getVarLbDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_470getVarLbDive}, + {"getVarUbDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_473getVarUbDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_472getVarUbDive}, + {"chgRowLhsDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_475chgRowLhsDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_474chgRowLhsDive}, + {"chgRowRhsDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_477chgRowRhsDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_476chgRowRhsDive}, + {"addRowDive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_479addRowDive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_478addRowDive}, + {"solveDiveLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_481solveDiveLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_480solveDiveLP}, + {"inRepropagation", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_483inRepropagation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_482inRepropagation}, + {"startProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_485startProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_484startProbing}, + {"endProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_487endProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_486endProbing}, + {"newProbingNode", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_489newProbingNode, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_488newProbingNode}, + {"backtrackProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_491backtrackProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_490backtrackProbing}, + {"getProbingDepth", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_493getProbingDepth, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_492getProbingDepth}, + {"chgVarObjProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_495chgVarObjProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_494chgVarObjProbing}, + {"chgVarLbProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_497chgVarLbProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_496chgVarLbProbing}, + {"chgVarUbProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_499chgVarUbProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_498chgVarUbProbing}, + {"fixVarProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_501fixVarProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_500fixVarProbing}, + {"isObjChangedProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_503isObjChangedProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_502isObjChangedProbing}, + {"inProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_505inProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_504inProbing}, + {"solveProbingLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_507solveProbingLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_506solveProbingLP}, + {"applyCutsProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_509applyCutsProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_508applyCutsProbing}, + {"propagateProbing", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_511propagateProbing, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_510propagateProbing}, + {"interruptSolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_513interruptSolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_512interruptSolve}, + {"restartSolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_515restartSolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_514restartSolve}, + {"writeLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_517writeLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_516writeLP}, + {"createSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_519createSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_518createSol}, + {"createPartialSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_521createPartialSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_520createPartialSol}, + {"createOrigSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_523createOrigSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_522createOrigSol}, + {"printBestSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_525printBestSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_524printBestSol}, + {"printSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_527printSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_526printSol}, + {"writeBestSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_529writeBestSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_528writeBestSol}, + {"writeBestTransSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_531writeBestTransSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_530writeBestTransSol}, + {"writeSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_533writeSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_532writeSol}, + {"writeTransSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_535writeTransSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_534writeTransSol}, + {"readSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_537readSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_536readSol}, + {"readSolFile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_539readSolFile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_538readSolFile}, + {"setSolVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_541setSolVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_540setSolVal}, + {"trySol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_543trySol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_542trySol}, + {"checkSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_545checkSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_544checkSol}, + {"addSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_547addSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_546addSol}, + {"freeSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_549freeSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_548freeSol}, + {"getNSols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_551getNSols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_550getNSols}, + {"getNSolsFound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_553getNSolsFound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_552getNSolsFound}, + {"getNLimSolsFound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_555getNLimSolsFound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_554getNLimSolsFound}, + {"getNBestSolsFound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_557getNBestSolsFound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_556getNBestSolsFound}, + {"getSols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_559getSols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_558getSols}, + {"getBestSol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_561getBestSol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_560getBestSol}, + {"getSolObjVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_563getSolObjVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_562getSolObjVal}, + {"getSolTime", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_565getSolTime, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_564getSolTime}, + {"getObjVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_567getObjVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_566getObjVal}, + {"getSolVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_569getSolVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_568getSolVal}, + {"getVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_571getVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_570getVal}, + {"hasPrimalRay", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_573hasPrimalRay, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_572hasPrimalRay}, + {"getPrimalRayVal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_575getPrimalRayVal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_574getPrimalRayVal}, + {"getPrimalRay", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_577getPrimalRay, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_576getPrimalRay}, + {"getPrimalbound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_579getPrimalbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_578getPrimalbound}, + {"getDualbound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_581getDualbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_580getDualbound}, + {"getDualboundRoot", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_583getDualboundRoot, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_582getDualboundRoot}, + {"writeName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_585writeName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_584writeName}, + {"getStage", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_587getStage, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_586getStage}, + {"getStageName", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_589getStageName, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_588getStageName}, + {"_getStageNames", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_591_getStageNames, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_590_getStageNames}, + {"getStatus", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_593getStatus, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_592getStatus}, + {"getObjectiveSense", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_595getObjectiveSense, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_594getObjectiveSense}, + {"catchEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_597catchEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_596catchEvent}, + {"dropEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_599dropEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_598dropEvent}, + {"catchVarEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_601catchVarEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_600catchVarEvent}, + {"dropVarEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_603dropVarEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_602dropVarEvent}, + {"catchRowEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_605catchRowEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_604catchRowEvent}, + {"dropRowEvent", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_607dropRowEvent, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_606dropRowEvent}, + {"printStatistics", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_609printStatistics, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_608printStatistics}, + {"writeStatistics", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_611writeStatistics, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_610writeStatistics}, + {"getNLPs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_613getNLPs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_612getNLPs}, + {"hideOutput", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_615hideOutput, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_614hideOutput}, + {"redirectOutput", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_617redirectOutput, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_616redirectOutput}, + {"setLogfile", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_619setLogfile, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_618setLogfile}, + {"setBoolParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_621setBoolParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_620setBoolParam}, + {"setIntParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_623setIntParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_622setIntParam}, + {"setLongintParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_625setLongintParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_624setLongintParam}, + {"setRealParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_627setRealParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_626setRealParam}, + {"setCharParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_629setCharParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_628setCharParam}, + {"setStringParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_631setStringParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_630setStringParam}, + {"setParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_633setParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_632setParam}, + {"getParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_635getParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_634getParam}, + {"getParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_637getParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_636getParams}, + {"setParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_639setParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_638setParams}, + {"readParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_641readParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_640readParams}, + {"writeParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_643writeParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_642writeParams}, + {"resetParam", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_645resetParam, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_644resetParam}, + {"resetParams", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_647resetParams, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_646resetParams}, + {"setEmphasis", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_649setEmphasis, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_648setEmphasis}, + {"readProblem", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_651readProblem, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_650readProblem}, + {"count", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_653count, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_652count}, + {"getNReaders", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_655getNReaders, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_654getNReaders}, + {"getNCountedSols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_657getNCountedSols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_656getNCountedSols}, + {"setParamsCountsols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_659setParamsCountsols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_658setParamsCountsols}, + {"freeReoptSolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_661freeReoptSolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_660freeReoptSolve}, + {"chgReoptObjective", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_663chgReoptObjective, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_662chgReoptObjective}, + {"chgVarBranchPriority", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_665chgVarBranchPriority, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_664chgVarBranchPriority}, + {"getTreesizeEstimation", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_667getTreesizeEstimation, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_666getTreesizeEstimation}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_669__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_668__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Model_671__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Model_670__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Model[] = { + {(char *)"_freescip", __pyx_getprop_9pyscipopt_4scip_5Model__freescip, __pyx_setprop_9pyscipopt_4scip_5Model__freescip, (char *)PyDoc_STR("Return whether the underlying Scip pointer gets deallocted when the current\n object is deleted.\n "), 0}, + {(char *)"data", __pyx_getprop_9pyscipopt_4scip_5Model_data, __pyx_setprop_9pyscipopt_4scip_5Model_data, (char *)PyDoc_STR("data: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Model_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Model}, + {Py_tp_hash, (void *)__pyx_pw_9pyscipopt_4scip_5Model_5__hash__}, + {Py_tp_doc, (void *)PyDoc_STR("Model(problemName=u'model', defaultPlugins=True, Model sourceModel=None, origcopy=False, globalcopy=True, enablepricing=False, createscip=True, threadsafe=False)\nMain class holding a pointer to SCIP for managing most interactions")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Model}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Model}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_9pyscipopt_4scip_Model}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Model}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Model}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_5Model_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Model}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Model_spec = { + "pyscipopt.scip.Model", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Model), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Model_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Model = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Model", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Model), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Model, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + __pyx_pw_9pyscipopt_4scip_5Model_5__hash__, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Model(problemName=u'model', defaultPlugins=True, Model sourceModel=None, origcopy=False, globalcopy=True, enablepricing=False, createscip=True, threadsafe=False)\nMain class holding a pointer to SCIP for managing most interactions"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Model, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Model, /*tp_clear*/ + __pyx_tp_richcompare_9pyscipopt_4scip_Model, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Model, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Model, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_5Model_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Model, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_ExprCons(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_ExprCons *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_ExprCons *)o); + p->expr = Py_None; Py_INCREF(Py_None); + p->_lhs = Py_None; Py_INCREF(Py_None); + p->_rhs = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_ExprCons(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_ExprCons *p = (struct __pyx_obj_9pyscipopt_4scip_ExprCons *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_ExprCons) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->expr); + Py_CLEAR(p->_lhs); + Py_CLEAR(p->_rhs); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_ExprCons(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_ExprCons *p = (struct __pyx_obj_9pyscipopt_4scip_ExprCons *)o; + if (p->expr) { + e = (*v)(p->expr, a); if (e) return e; + } + if (p->_lhs) { + e = (*v)(p->_lhs, a); if (e) return e; + } + if (p->_rhs) { + e = (*v)(p->_rhs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_ExprCons(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_ExprCons *p = (struct __pyx_obj_9pyscipopt_4scip_ExprCons *)o; + tmp = ((PyObject*)p->expr); + p->expr = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_lhs); + p->_lhs = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_rhs); + p->_rhs = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8ExprCons_expr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8ExprCons_expr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4expr_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8ExprCons__lhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8ExprCons__lhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4_lhs_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8ExprCons__rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8ExprCons__rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_4_rhs_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8ExprCons_7__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_8ExprCons_7__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_ExprCons[] = { + {"normalize", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ExprCons_3normalize, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ExprCons_2normalize}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8ExprCons_7__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ExprCons_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ExprCons_10__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ExprCons_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ExprCons_12__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_ExprCons[] = { + {(char *)"expr", __pyx_getprop_9pyscipopt_4scip_8ExprCons_expr, __pyx_setprop_9pyscipopt_4scip_8ExprCons_expr, (char *)PyDoc_STR("expr: object"), 0}, + {(char *)"_lhs", __pyx_getprop_9pyscipopt_4scip_8ExprCons__lhs, __pyx_setprop_9pyscipopt_4scip_8ExprCons__lhs, (char *)PyDoc_STR("_lhs: object"), 0}, + {(char *)"_rhs", __pyx_getprop_9pyscipopt_4scip_8ExprCons__rhs, __pyx_setprop_9pyscipopt_4scip_8ExprCons__rhs, (char *)PyDoc_STR("_rhs: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_ExprCons_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_ExprCons}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_8ExprCons_7__repr__}, + {Py_nb_bool, (void *)__pyx_pw_9pyscipopt_4scip_8ExprCons_9__nonzero__}, + {Py_tp_doc, (void *)PyDoc_STR("ExprCons(expr, lhs=None, rhs=None)\nConstraints with a polynomial expressions and lower/upper bounds.")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_ExprCons}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_ExprCons}, + {Py_tp_richcompare, (void *)__pyx_pw_9pyscipopt_4scip_8ExprCons_5__richcmp__}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_ExprCons}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_ExprCons}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_8ExprCons_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_ExprCons}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_ExprCons_spec = { + "pyscipopt.scip.ExprCons", + sizeof(struct __pyx_obj_9pyscipopt_4scip_ExprCons), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_ExprCons_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_ExprCons = { + 0, /*nb_add*/ + 0, /*nb_subtract*/ + 0, /*nb_multiply*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_divide*/ + #endif + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + 0, /*nb_power*/ + 0, /*nb_negative*/ + 0, /*nb_positive*/ + 0, /*nb_absolute*/ + __pyx_pw_9pyscipopt_4scip_8ExprCons_9__nonzero__, /*nb_bool*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_coerce*/ + #endif + 0, /*nb_int*/ + #if PY_MAJOR_VERSION < 3 + 0, /*nb_long*/ + #else + 0, /*reserved*/ + #endif + 0, /*nb_float*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_oct*/ + #endif + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_hex*/ + #endif + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_inplace_divide*/ + #endif + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + 0, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_matrix_multiply*/ + #endif + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_inplace_matrix_multiply*/ + #endif +}; + +static PyTypeObject __pyx_type_9pyscipopt_4scip_ExprCons = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""ExprCons", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_ExprCons), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_ExprCons, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_8ExprCons_7__repr__, /*tp_repr*/ + &__pyx_tp_as_number_ExprCons, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("ExprCons(expr, lhs=None, rhs=None)\nConstraints with a polynomial expressions and lower/upper bounds."), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_ExprCons, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_ExprCons, /*tp_clear*/ + __pyx_pw_9pyscipopt_4scip_8ExprCons_5__richcmp__, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_ExprCons, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_ExprCons, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_8ExprCons_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_ExprCons, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_GenExpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_GenExpr *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_GenExpr *)o); + p->_op = Py_None; Py_INCREF(Py_None); + p->children = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_GenExpr *p = (struct __pyx_obj_9pyscipopt_4scip_GenExpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->_op); + Py_CLEAR(p->children); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_GenExpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_GenExpr *p = (struct __pyx_obj_9pyscipopt_4scip_GenExpr *)o; + if (p->_op) { + e = (*v)(p->_op, a); if (e) return e; + } + if (p->children) { + e = (*v)(p->children, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_GenExpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_GenExpr *p = (struct __pyx_obj_9pyscipopt_4scip_GenExpr *)o; + tmp = ((PyObject*)p->_op); + p->_op = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->children); + p->children = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static CYTHON_INLINE PyObject *__pyx_nb_add_9pyscipopt_4scip_GenExpr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_add : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_add); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_add_9pyscipopt_4scip_GenExpr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_add == &__pyx_nb_add_9pyscipopt_4scip_GenExpr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_7GenExpr_5__add__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_add == &__pyx_nb_add_9pyscipopt_4scip_GenExpr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_right) { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_19__radd__(right, left); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static CYTHON_INLINE PyObject *__pyx_nb_subtract_9pyscipopt_4scip_GenExpr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_subtract : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_subtract); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_subtract_9pyscipopt_4scip_GenExpr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_subtract == &__pyx_nb_subtract_9pyscipopt_4scip_GenExpr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_7GenExpr_17__sub__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_subtract == &__pyx_nb_subtract_9pyscipopt_4scip_GenExpr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_right) { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_23__rsub__(right, left); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static CYTHON_INLINE PyObject *__pyx_nb_multiply_9pyscipopt_4scip_GenExpr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_multiply : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_multiply); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_multiply_9pyscipopt_4scip_GenExpr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_multiply == &__pyx_nb_multiply_9pyscipopt_4scip_GenExpr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_7GenExpr_7__mul__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_multiply == &__pyx_nb_multiply_9pyscipopt_4scip_GenExpr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_right) { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_21__rmul__(right, left); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static CYTHON_INLINE PyObject *__pyx_nb_power_9pyscipopt_4scip_GenExpr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right , PyObject* extra_arg) { + ternaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_power : NULL; +#else + slot = (ternaryfunc) PyType_GetSlot(type, Py_nb_power); +#endif + return slot ? slot(left, right , extra_arg) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_power_9pyscipopt_4scip_GenExpr(PyObject *left, PyObject *right , PyObject* extra_arg) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_power == &__pyx_nb_power_9pyscipopt_4scip_GenExpr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_7GenExpr_9__pow__(left, right, extra_arg); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_power == &__pyx_nb_power_9pyscipopt_4scip_GenExpr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_right) { + return __pyx_nb_power_9pyscipopt_4scip_GenExpr_maybe_call_slot(__Pyx_PyType_GetSlot(__pyx_ptype_9pyscipopt_4scip_GenExpr, tp_base, PyTypeObject*), left, right , extra_arg); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static CYTHON_INLINE PyObject *__pyx_nb_true_divide_9pyscipopt_4scip_GenExpr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_true_divide : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_true_divide); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_true_divide_9pyscipopt_4scip_GenExpr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_true_divide == &__pyx_nb_true_divide_9pyscipopt_4scip_GenExpr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_9pyscipopt_4scip_7GenExpr_11__truediv__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_true_divide == &__pyx_nb_true_divide_9pyscipopt_4scip_GenExpr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_9pyscipopt_4scip_GenExpr); + if (maybe_self_is_right) { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_13__rtruediv__(right, left); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7GenExpr__op(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7GenExpr__op(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_3_op_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7GenExpr_children(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_8children_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7GenExpr_children(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_8children_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7GenExpr_8children_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_GenExpr[] = { + {"__rtruediv__", (PyCFunction)__pyx_pw_9pyscipopt_4scip_7GenExpr_13__rtruediv__, METH_O|METH_COEXIST, __pyx_doc_9pyscipopt_4scip_7GenExpr_12__rtruediv__}, + {"__radd__", (PyCFunction)__pyx_pw_9pyscipopt_4scip_7GenExpr_19__radd__, METH_O|METH_COEXIST, 0}, + {"__rmul__", (PyCFunction)__pyx_pw_9pyscipopt_4scip_7GenExpr_21__rmul__, METH_O|METH_COEXIST, 0}, + {"__rsub__", (PyCFunction)__pyx_pw_9pyscipopt_4scip_7GenExpr_23__rsub__, METH_O|METH_COEXIST, 0}, + {"degree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7GenExpr_27degree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7GenExpr_26degree}, + {"getOp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7GenExpr_29getOp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7GenExpr_28getOp}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7GenExpr_31__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7GenExpr_30__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7GenExpr_33__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7GenExpr_32__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_GenExpr[] = { + {(char *)"_op", __pyx_getprop_9pyscipopt_4scip_7GenExpr__op, __pyx_setprop_9pyscipopt_4scip_7GenExpr__op, (char *)PyDoc_STR("_op: object"), 0}, + {(char *)"children", __pyx_getprop_9pyscipopt_4scip_7GenExpr_children, __pyx_setprop_9pyscipopt_4scip_7GenExpr_children, (char *)PyDoc_STR("children: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_GenExpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_GenExpr}, + {Py_nb_add, (void *)__pyx_nb_add_9pyscipopt_4scip_GenExpr}, + {Py_nb_subtract, (void *)__pyx_nb_subtract_9pyscipopt_4scip_GenExpr}, + {Py_nb_multiply, (void *)__pyx_nb_multiply_9pyscipopt_4scip_GenExpr}, + {Py_nb_power, (void *)__pyx_nb_power_9pyscipopt_4scip_GenExpr}, + {Py_nb_negative, (void *)__pyx_pw_9pyscipopt_4scip_7GenExpr_15__neg__}, + {Py_nb_absolute, (void *)__pyx_pw_9pyscipopt_4scip_7GenExpr_3__abs__}, + {Py_nb_true_divide, (void *)__pyx_nb_true_divide_9pyscipopt_4scip_GenExpr}, + {Py_tp_doc, (void *)PyDoc_STR("GenExpr()")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_GenExpr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_GenExpr}, + {Py_tp_richcompare, (void *)__pyx_pw_9pyscipopt_4scip_7GenExpr_25__richcmp__}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_GenExpr}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_GenExpr}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_7GenExpr_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_GenExpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_GenExpr_spec = { + "pyscipopt.scip.GenExpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_GenExpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_GenExpr_slots, +}; +#else + +static PyNumberMethods __pyx_tp_as_number_GenExpr = { + __pyx_nb_add_9pyscipopt_4scip_GenExpr, /*nb_add*/ + __pyx_nb_subtract_9pyscipopt_4scip_GenExpr, /*nb_subtract*/ + __pyx_nb_multiply_9pyscipopt_4scip_GenExpr, /*nb_multiply*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_divide*/ + #endif + 0, /*nb_remainder*/ + 0, /*nb_divmod*/ + __pyx_nb_power_9pyscipopt_4scip_GenExpr, /*nb_power*/ + __pyx_pw_9pyscipopt_4scip_7GenExpr_15__neg__, /*nb_negative*/ + 0, /*nb_positive*/ + __pyx_pw_9pyscipopt_4scip_7GenExpr_3__abs__, /*nb_absolute*/ + 0, /*nb_bool*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_coerce*/ + #endif + 0, /*nb_int*/ + #if PY_MAJOR_VERSION < 3 + 0, /*nb_long*/ + #else + 0, /*reserved*/ + #endif + 0, /*nb_float*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_oct*/ + #endif + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_hex*/ + #endif + 0, /*nb_inplace_add*/ + 0, /*nb_inplace_subtract*/ + 0, /*nb_inplace_multiply*/ + #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) + 0, /*nb_inplace_divide*/ + #endif + 0, /*nb_inplace_remainder*/ + 0, /*nb_inplace_power*/ + 0, /*nb_inplace_lshift*/ + 0, /*nb_inplace_rshift*/ + 0, /*nb_inplace_and*/ + 0, /*nb_inplace_xor*/ + 0, /*nb_inplace_or*/ + 0, /*nb_floor_divide*/ + __pyx_nb_true_divide_9pyscipopt_4scip_GenExpr, /*nb_true_divide*/ + 0, /*nb_inplace_floor_divide*/ + 0, /*nb_inplace_true_divide*/ + 0, /*nb_index*/ + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_matrix_multiply*/ + #endif + #if PY_VERSION_HEX >= 0x03050000 + 0, /*nb_inplace_matrix_multiply*/ + #endif +}; + +static PyTypeObject __pyx_type_9pyscipopt_4scip_GenExpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""GenExpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_GenExpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + &__pyx_tp_as_number_GenExpr, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("GenExpr()"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_GenExpr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_GenExpr, /*tp_clear*/ + __pyx_pw_9pyscipopt_4scip_7GenExpr_25__richcmp__, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_GenExpr, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_GenExpr, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_7GenExpr_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_GenExpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_SumExpr(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_SumExpr *p; + PyObject *o = __pyx_tp_new_9pyscipopt_4scip_GenExpr(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pyscipopt_4scip_SumExpr *)o); + p->constant = Py_None; Py_INCREF(Py_None); + p->coefs = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_SumExpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_SumExpr *p = (struct __pyx_obj_9pyscipopt_4scip_SumExpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_SumExpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->constant); + Py_CLEAR(p->coefs); + PyObject_GC_Track(o); + __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr(o); +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_SumExpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_SumExpr *p = (struct __pyx_obj_9pyscipopt_4scip_SumExpr *)o; + e = __pyx_tp_traverse_9pyscipopt_4scip_GenExpr(o, v, a); if (e) return e; + if (p->constant) { + e = (*v)(p->constant, a); if (e) return e; + } + if (p->coefs) { + e = (*v)(p->coefs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_SumExpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_SumExpr *p = (struct __pyx_obj_9pyscipopt_4scip_SumExpr *)o; + __pyx_tp_clear_9pyscipopt_4scip_GenExpr(o); + tmp = ((PyObject*)p->constant); + p->constant = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->coefs); + p->coefs = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7SumExpr_constant(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7SumExpr_constant(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7SumExpr_8constant_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7SumExpr_coefs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7SumExpr_coefs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7SumExpr_5coefs_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_7SumExpr_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_7SumExpr_3__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_SumExpr[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_7SumExpr_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7SumExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7SumExpr_4__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7SumExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7SumExpr_6__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_SumExpr[] = { + {(char *)"constant", __pyx_getprop_9pyscipopt_4scip_7SumExpr_constant, __pyx_setprop_9pyscipopt_4scip_7SumExpr_constant, (char *)PyDoc_STR("constant: object"), 0}, + {(char *)"coefs", __pyx_getprop_9pyscipopt_4scip_7SumExpr_coefs, __pyx_setprop_9pyscipopt_4scip_7SumExpr_coefs, (char *)PyDoc_STR("coefs: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_SumExpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_SumExpr}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_7SumExpr_3__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("SumExpr()")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_SumExpr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_SumExpr}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_SumExpr}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_SumExpr}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_7SumExpr_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_SumExpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_SumExpr_spec = { + "pyscipopt.scip.SumExpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_SumExpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_SumExpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_SumExpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""SumExpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_SumExpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_SumExpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_7SumExpr_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("SumExpr()"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_SumExpr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_SumExpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_SumExpr, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_SumExpr, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_7SumExpr_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_SumExpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_ProdExpr(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_ProdExpr *p; + PyObject *o = __pyx_tp_new_9pyscipopt_4scip_GenExpr(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)o); + p->constant = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_ProdExpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_ProdExpr *p = (struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_ProdExpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->constant); + PyObject_GC_Track(o); + __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr(o); +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_ProdExpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_ProdExpr *p = (struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)o; + e = __pyx_tp_traverse_9pyscipopt_4scip_GenExpr(o, v, a); if (e) return e; + if (p->constant) { + e = (*v)(p->constant, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_ProdExpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_ProdExpr *p = (struct __pyx_obj_9pyscipopt_4scip_ProdExpr *)o; + __pyx_tp_clear_9pyscipopt_4scip_GenExpr(o); + tmp = ((PyObject*)p->constant); + p->constant = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8ProdExpr_constant(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8ProdExpr_constant(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8ProdExpr_8constant_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8ProdExpr_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_8ProdExpr_3__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_ProdExpr[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8ProdExpr_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ProdExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ProdExpr_4__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8ProdExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8ProdExpr_6__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_ProdExpr[] = { + {(char *)"constant", __pyx_getprop_9pyscipopt_4scip_8ProdExpr_constant, __pyx_setprop_9pyscipopt_4scip_8ProdExpr_constant, (char *)PyDoc_STR("constant: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_ProdExpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_ProdExpr}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_8ProdExpr_3__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("ProdExpr()")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_ProdExpr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_ProdExpr}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_ProdExpr}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_ProdExpr}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_8ProdExpr_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_ProdExpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_ProdExpr_spec = { + "pyscipopt.scip.ProdExpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_ProdExpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_ProdExpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_ProdExpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""ProdExpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_ProdExpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_ProdExpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_8ProdExpr_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("ProdExpr()"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_ProdExpr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_ProdExpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_ProdExpr, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_ProdExpr, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_8ProdExpr_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_ProdExpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_VarExpr(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_VarExpr *p; + PyObject *o = __pyx_tp_new_9pyscipopt_4scip_GenExpr(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pyscipopt_4scip_VarExpr *)o); + p->var = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_VarExpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_VarExpr *p = (struct __pyx_obj_9pyscipopt_4scip_VarExpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_VarExpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->var); + PyObject_GC_Track(o); + __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr(o); +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_VarExpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_VarExpr *p = (struct __pyx_obj_9pyscipopt_4scip_VarExpr *)o; + e = __pyx_tp_traverse_9pyscipopt_4scip_GenExpr(o, v, a); if (e) return e; + if (p->var) { + e = (*v)(p->var, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_VarExpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_VarExpr *p = (struct __pyx_obj_9pyscipopt_4scip_VarExpr *)o; + __pyx_tp_clear_9pyscipopt_4scip_GenExpr(o); + tmp = ((PyObject*)p->var); + p->var = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7VarExpr_var(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7VarExpr_3var_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7VarExpr_var(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7VarExpr_3var_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7VarExpr_3var_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_7VarExpr_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_7VarExpr_3__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_VarExpr[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_7VarExpr_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7VarExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7VarExpr_4__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7VarExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7VarExpr_6__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_VarExpr[] = { + {(char *)"var", __pyx_getprop_9pyscipopt_4scip_7VarExpr_var, __pyx_setprop_9pyscipopt_4scip_7VarExpr_var, (char *)PyDoc_STR("var: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_VarExpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_VarExpr}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_7VarExpr_3__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("VarExpr(var)")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_VarExpr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_VarExpr}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_VarExpr}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_VarExpr}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_7VarExpr_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_VarExpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_VarExpr_spec = { + "pyscipopt.scip.VarExpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_VarExpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_VarExpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_VarExpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""VarExpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_VarExpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_VarExpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_7VarExpr_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("VarExpr(var)"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_VarExpr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_VarExpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_VarExpr, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_VarExpr, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_7VarExpr_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_VarExpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PowExpr(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_PowExpr *p; + PyObject *o = __pyx_tp_new_9pyscipopt_4scip_GenExpr(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pyscipopt_4scip_PowExpr *)o); + p->expo = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PowExpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_PowExpr *p = (struct __pyx_obj_9pyscipopt_4scip_PowExpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PowExpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->expo); + PyObject_GC_Track(o); + __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr(o); +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_PowExpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_PowExpr *p = (struct __pyx_obj_9pyscipopt_4scip_PowExpr *)o; + e = __pyx_tp_traverse_9pyscipopt_4scip_GenExpr(o, v, a); if (e) return e; + if (p->expo) { + e = (*v)(p->expo, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_PowExpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_PowExpr *p = (struct __pyx_obj_9pyscipopt_4scip_PowExpr *)o; + __pyx_tp_clear_9pyscipopt_4scip_GenExpr(o); + tmp = ((PyObject*)p->expo); + p->expo = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7PowExpr_expo(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7PowExpr_expo(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7PowExpr_4expo_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_7PowExpr_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_7PowExpr_3__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PowExpr[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_7PowExpr_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7PowExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7PowExpr_4__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7PowExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7PowExpr_6__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_PowExpr[] = { + {(char *)"expo", __pyx_getprop_9pyscipopt_4scip_7PowExpr_expo, __pyx_setprop_9pyscipopt_4scip_7PowExpr_expo, (char *)PyDoc_STR("expo: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PowExpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PowExpr}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_7PowExpr_3__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("PowExpr()")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_PowExpr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_PowExpr}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PowExpr}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_PowExpr}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_7PowExpr_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PowExpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PowExpr_spec = { + "pyscipopt.scip.PowExpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PowExpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_PowExpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PowExpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PowExpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PowExpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PowExpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_7PowExpr_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("PowExpr()"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_PowExpr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_PowExpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PowExpr, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_PowExpr, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_7PowExpr_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PowExpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_9UnaryExpr_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_9UnaryExpr_3__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_UnaryExpr[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_9UnaryExpr_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9UnaryExpr_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9UnaryExpr_4__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9UnaryExpr_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9UnaryExpr_6__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_UnaryExpr_slots[] = { + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_9UnaryExpr_3__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("UnaryExpr(op, expr)")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_GenExpr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_GenExpr}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_UnaryExpr}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_9UnaryExpr_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_GenExpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_UnaryExpr_spec = { + "pyscipopt.scip.UnaryExpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_UnaryExpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_UnaryExpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""UnaryExpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_UnaryExpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_9UnaryExpr_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("UnaryExpr(op, expr)"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_GenExpr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_GenExpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_UnaryExpr, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_9UnaryExpr_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_GenExpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Constant(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Constant *p; + PyObject *o = __pyx_tp_new_9pyscipopt_4scip_GenExpr(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_9pyscipopt_4scip_Constant *)o); + p->number = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Constant(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Constant *p = (struct __pyx_obj_9pyscipopt_4scip_Constant *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Constant) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->number); + PyObject_GC_Track(o); + __pyx_tp_dealloc_9pyscipopt_4scip_GenExpr(o); +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Constant(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Constant *p = (struct __pyx_obj_9pyscipopt_4scip_Constant *)o; + e = __pyx_tp_traverse_9pyscipopt_4scip_GenExpr(o, v, a); if (e) return e; + if (p->number) { + e = (*v)(p->number, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Constant(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Constant *p = (struct __pyx_obj_9pyscipopt_4scip_Constant *)o; + __pyx_tp_clear_9pyscipopt_4scip_GenExpr(o); + tmp = ((PyObject*)p->number); + p->number = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8Constant_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8Constant_6number_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8Constant_number(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8Constant_6number_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8Constant_6number_5__del__(o); + } +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8Constant_3__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_8Constant_3__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Constant[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_8Constant_3__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Constant_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Constant_4__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Constant_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Constant_6__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Constant[] = { + {(char *)"number", __pyx_getprop_9pyscipopt_4scip_8Constant_number, __pyx_setprop_9pyscipopt_4scip_8Constant_number, (char *)PyDoc_STR("number: object"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Constant_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Constant}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_8Constant_3__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("Constant(number)")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Constant}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Constant}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Constant}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Constant}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_8Constant_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Constant}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Constant_spec = { + "pyscipopt.scip.Constant", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Constant), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Constant_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Constant = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Constant", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Constant), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Constant, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_8Constant_3__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + PyDoc_STR("Constant(number)"), /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Constant, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Constant, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Constant, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Constant, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_8Constant_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Constant, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_LP(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_LP *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_LP *)o); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_LP(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_LP *p = (struct __pyx_obj_9pyscipopt_4scip_LP *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_LP) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_pw_9pyscipopt_4scip_2LP_3__dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_2LP_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_2LP_4name_1__get__(o); +} + +static PyObject *__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_2LP_5__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_9pyscipopt_4scip_2LP_5__repr__(self); +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_LP[] = { + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_9pyscipopt_4scip_2LP_5__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"writeLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_7writeLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_6writeLP}, + {"readLP", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_9readLP, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_8readLP}, + {"infinity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_11infinity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_10infinity}, + {"isInfinity", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_13isInfinity, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_12isInfinity}, + {"addCol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_15addCol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_14addCol}, + {"addCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_17addCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_16addCols}, + {"delCols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_19delCols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_18delCols}, + {"addRow", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_21addRow, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_20addRow}, + {"addRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_23addRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_22addRows}, + {"delRows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_25delRows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_24delRows}, + {"getBounds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_27getBounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_26getBounds}, + {"getSides", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_29getSides, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_28getSides}, + {"chgObj", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_31chgObj, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_30chgObj}, + {"chgCoef", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_33chgCoef, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_32chgCoef}, + {"chgBound", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_35chgBound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_34chgBound}, + {"chgSide", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_37chgSide, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_36chgSide}, + {"clear", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_39clear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_38clear}, + {"nrows", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_41nrows, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_40nrows}, + {"ncols", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_43ncols, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_42ncols}, + {"solve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_45solve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_44solve}, + {"getPrimal", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_47getPrimal, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_46getPrimal}, + {"isPrimalFeasible", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_49isPrimalFeasible, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_48isPrimalFeasible}, + {"getDual", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_51getDual, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_50getDual}, + {"isDualFeasible", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_53isDualFeasible, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_52isDualFeasible}, + {"getPrimalRay", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_55getPrimalRay, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_54getPrimalRay}, + {"getDualRay", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_57getDualRay, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_56getDualRay}, + {"getNIterations", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_59getNIterations, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_58getNIterations}, + {"getRedcost", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_61getRedcost, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_60getRedcost}, + {"getBasisInds", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_63getBasisInds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_62getBasisInds}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_65__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_64__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_2LP_67__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_2LP_66__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_LP[] = { + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_2LP_name, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_LP_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_LP}, + {Py_tp_repr, (void *)__pyx_pw_9pyscipopt_4scip_2LP_5__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("LP(name=u'LP', sense=u'minimize')")}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_LP}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_LP}, + {Py_tp_init, (void *)__pyx_pw_9pyscipopt_4scip_2LP_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_LP}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_LP_spec = { + "pyscipopt.scip.LP", + sizeof(struct __pyx_obj_9pyscipopt_4scip_LP), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_LP_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_LP = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""LP", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_LP), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_LP, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_pw_9pyscipopt_4scip_2LP_5__repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + PyDoc_STR("LP(name=u'LP', sense=u'minimize')"), /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_LP, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_LP, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_9pyscipopt_4scip_2LP_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_LP, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Benders(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Benders *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Benders(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Benders *p = (struct __pyx_obj_9pyscipopt_4scip_Benders *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Benders) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Benders(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Benders *p = (struct __pyx_obj_9pyscipopt_4scip_Benders *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Benders(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Benders *p = (struct __pyx_obj_9pyscipopt_4scip_Benders *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7Benders_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7Benders_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7Benders_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7Benders_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7Benders_5model_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7Benders_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7Benders_4name_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7Benders_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7Benders_4name_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7Benders_4name_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Benders[] = { + {"bendersfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_1bendersfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_bendersfree}, + {"bendersinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_3bendersinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_2bendersinit}, + {"bendersexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_5bendersexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_4bendersexit}, + {"bendersinitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_7bendersinitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_6bendersinitpre}, + {"bendersexitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_9bendersexitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_8bendersexitpre}, + {"bendersinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_11bendersinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_10bendersinitsol}, + {"bendersexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_13bendersexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_12bendersexitsol}, + {"benderscreatesub", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_15benderscreatesub, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_14benderscreatesub}, + {"benderspresubsolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_17benderspresubsolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_16benderspresubsolve}, + {"benderssolvesubconvex", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_19benderssolvesubconvex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_18benderssolvesubconvex}, + {"benderssolvesub", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_21benderssolvesub, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_20benderssolvesub}, + {"benderspostsolve", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_23benderspostsolve, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_22benderspostsolve}, + {"bendersfreesub", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_25bendersfreesub, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_24bendersfreesub}, + {"bendersgetvar", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_27bendersgetvar, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_26bendersgetvar}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_29__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_28__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Benders_31__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Benders_30__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Benders[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_7Benders_model, __pyx_setprop_9pyscipopt_4scip_7Benders_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_7Benders_name, __pyx_setprop_9pyscipopt_4scip_7Benders_name, (char *)PyDoc_STR("name: unicode"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Benders_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Benders}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Benders}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Benders}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Benders}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Benders}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Benders}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Benders_spec = { + "pyscipopt.scip.Benders", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Benders), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Benders_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Benders = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Benders", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Benders), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Benders, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Benders, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Benders, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Benders, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Benders, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Benders, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Benderscut(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Benderscut *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Benderscut *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + p->benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None); Py_INCREF(Py_None); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Benderscut(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Benderscut *p = (struct __pyx_obj_9pyscipopt_4scip_Benderscut *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Benderscut) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + Py_CLEAR(p->benders); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Benderscut(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *p = (struct __pyx_obj_9pyscipopt_4scip_Benderscut *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + if (p->benders) { + e = (*v)(((PyObject *)p->benders), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Benderscut(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Benderscut *p = (struct __pyx_obj_9pyscipopt_4scip_Benderscut *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->benders); + p->benders = ((struct __pyx_obj_9pyscipopt_4scip_Benders *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_10Benderscut_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_10Benderscut_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_5model_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_10Benderscut_benders(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_10Benderscut_benders(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_7benders_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_10Benderscut_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_4name_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_10Benderscut_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_4name_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_10Benderscut_4name_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Benderscut[] = { + {"benderscutfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_1benderscutfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_benderscutfree}, + {"benderscutinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_3benderscutinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_2benderscutinit}, + {"benderscutexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_5benderscutexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_4benderscutexit}, + {"benderscutinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_7benderscutinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_6benderscutinitsol}, + {"benderscutexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_9benderscutexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_8benderscutexitsol}, + {"benderscutexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_11benderscutexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_10benderscutexec}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_12__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Benderscut_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Benderscut_14__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Benderscut[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_10Benderscut_model, __pyx_setprop_9pyscipopt_4scip_10Benderscut_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {(char *)"benders", __pyx_getprop_9pyscipopt_4scip_10Benderscut_benders, __pyx_setprop_9pyscipopt_4scip_10Benderscut_benders, (char *)PyDoc_STR("benders: pyscipopt.scip.Benders"), 0}, + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_10Benderscut_name, __pyx_setprop_9pyscipopt_4scip_10Benderscut_name, (char *)PyDoc_STR("name: unicode"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Benderscut_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Benderscut}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Benderscut}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Benderscut}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Benderscut}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Benderscut}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Benderscut}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Benderscut_spec = { + "pyscipopt.scip.Benderscut", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Benderscut), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Benderscut_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Benderscut = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Benderscut", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Benderscut), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Benderscut, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Benderscut, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Benderscut, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Benderscut, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Benderscut, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Benderscut, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Branchrule(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Branchrule *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Branchrule *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Branchrule(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Branchrule *p = (struct __pyx_obj_9pyscipopt_4scip_Branchrule *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Branchrule) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Branchrule(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *p = (struct __pyx_obj_9pyscipopt_4scip_Branchrule *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Branchrule(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Branchrule *p = (struct __pyx_obj_9pyscipopt_4scip_Branchrule *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_10Branchrule_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_10Branchrule_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_10Branchrule_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_10Branchrule_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_10Branchrule_5model_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Branchrule[] = { + {"branchfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_1branchfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_branchfree}, + {"branchinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_3branchinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_2branchinit}, + {"branchexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_5branchexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_4branchexit}, + {"branchinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_7branchinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_6branchinitsol}, + {"branchexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_9branchexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_8branchexitsol}, + {"branchexeclp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_11branchexeclp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_10branchexeclp}, + {"branchexecext", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_13branchexecext, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_12branchexecext}, + {"branchexecps", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_15branchexecps, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_14branchexecps}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_16__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_10Branchrule_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_10Branchrule_18__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Branchrule[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_10Branchrule_model, __pyx_setprop_9pyscipopt_4scip_10Branchrule_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Branchrule_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Branchrule}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Branchrule}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Branchrule}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Branchrule}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Branchrule}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Branchrule}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Branchrule_spec = { + "pyscipopt.scip.Branchrule", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Branchrule), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Branchrule_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Branchrule = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Branchrule", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Branchrule), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Branchrule, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Branchrule, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Branchrule, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Branchrule, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Branchrule, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Branchrule, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Conshdlr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Conshdlr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *p = (struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Conshdlr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Conshdlr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *p = (struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Conshdlr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Conshdlr *p = (struct __pyx_obj_9pyscipopt_4scip_Conshdlr *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8Conshdlr_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8Conshdlr_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8Conshdlr_5model_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_8Conshdlr_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_8Conshdlr_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_8Conshdlr_4name_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Conshdlr[] = { + {"consfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_1consfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_consfree}, + {"consinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_3consinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_2consinit}, + {"consexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_5consexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_4consexit}, + {"consinitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_7consinitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_6consinitpre}, + {"consexitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_9consexitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_8consexitpre}, + {"consinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_11consinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_10consinitsol}, + {"consexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_13consexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_12consexitsol}, + {"consdelete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_15consdelete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_14consdelete}, + {"constrans", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_17constrans, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_16constrans}, + {"consinitlp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_19consinitlp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_18consinitlp}, + {"conssepalp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_21conssepalp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_20conssepalp}, + {"conssepasol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_23conssepasol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_22conssepasol}, + {"consenfolp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_25consenfolp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_24consenfolp}, + {"consenforelax", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_27consenforelax, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_26consenforelax}, + {"consenfops", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_29consenfops, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_28consenfops}, + {"conscheck", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_31conscheck, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_30conscheck}, + {"consprop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_33consprop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_32consprop}, + {"conspresol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_35conspresol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_34conspresol}, + {"consresprop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_37consresprop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_36consresprop}, + {"conslock", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_39conslock, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_38conslock}, + {"consactive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_41consactive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_40consactive}, + {"consdeactive", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_43consdeactive, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_42consdeactive}, + {"consenable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_45consenable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_44consenable}, + {"consdisable", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_47consdisable, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_46consdisable}, + {"consdelvars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_49consdelvars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_48consdelvars}, + {"consprint", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_51consprint, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_50consprint}, + {"conscopy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_53conscopy, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_52conscopy}, + {"consparse", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_55consparse, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_54consparse}, + {"consgetvars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_57consgetvars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_56consgetvars}, + {"consgetnvars", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_59consgetnvars, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_58consgetnvars}, + {"consgetdivebdchgs", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_61consgetdivebdchgs, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_60consgetdivebdchgs}, + {"consgetpermsymgraph", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_63consgetpermsymgraph, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_62consgetpermsymgraph}, + {"consgetsignedpermsymgraph", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_65consgetsignedpermsymgraph, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_64consgetsignedpermsymgraph}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_67__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_66__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_8Conshdlr_69__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_8Conshdlr_68__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Conshdlr[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_8Conshdlr_model, __pyx_setprop_9pyscipopt_4scip_8Conshdlr_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_8Conshdlr_name, __pyx_setprop_9pyscipopt_4scip_8Conshdlr_name, (char *)PyDoc_STR("name: unicode"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Conshdlr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Conshdlr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Conshdlr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Conshdlr}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Conshdlr}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Conshdlr}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Conshdlr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Conshdlr_spec = { + "pyscipopt.scip.Conshdlr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Conshdlr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Conshdlr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Conshdlr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Conshdlr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Conshdlr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Conshdlr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Conshdlr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Conshdlr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Conshdlr, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Conshdlr, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Conshdlr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Cutsel(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Cutsel *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Cutsel *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Cutsel(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Cutsel *p = (struct __pyx_obj_9pyscipopt_4scip_Cutsel *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Cutsel) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Cutsel(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Cutsel *p = (struct __pyx_obj_9pyscipopt_4scip_Cutsel *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Cutsel(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Cutsel *p = (struct __pyx_obj_9pyscipopt_4scip_Cutsel *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_6Cutsel_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_6Cutsel_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_6Cutsel_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_6Cutsel_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_6Cutsel_5model_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Cutsel[] = { + {"cutselfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_1cutselfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_cutselfree}, + {"cutselinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_3cutselinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_2cutselinit}, + {"cutselexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_5cutselexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_4cutselexit}, + {"cutselinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_7cutselinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_6cutselinitsol}, + {"cutselexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_9cutselexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_8cutselexitsol}, + {"cutselselect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_11cutselselect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_10cutselselect}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_12__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Cutsel_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Cutsel_14__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Cutsel[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_6Cutsel_model, __pyx_setprop_9pyscipopt_4scip_6Cutsel_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Cutsel_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Cutsel}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Cutsel}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Cutsel}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Cutsel}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Cutsel}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Cutsel}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Cutsel_spec = { + "pyscipopt.scip.Cutsel", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Cutsel), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Cutsel_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Cutsel = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Cutsel", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Cutsel), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Cutsel, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Cutsel, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Cutsel, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Cutsel, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Cutsel, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Cutsel, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Eventhdlr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Eventhdlr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *p = (struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Eventhdlr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Eventhdlr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *p = (struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Eventhdlr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *p = (struct __pyx_obj_9pyscipopt_4scip_Eventhdlr *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_9Eventhdlr_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_9Eventhdlr_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_9Eventhdlr_5model_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_9Eventhdlr_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_9Eventhdlr_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_9Eventhdlr_4name_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Eventhdlr[] = { + {"eventcopy", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_1eventcopy, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_eventcopy}, + {"eventfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_3eventfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_2eventfree}, + {"eventinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_5eventinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_4eventinit}, + {"eventexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_7eventexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_6eventexit}, + {"eventinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_9eventinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_8eventinitsol}, + {"eventexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_11eventexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_10eventexitsol}, + {"eventdelete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_13eventdelete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_12eventdelete}, + {"eventexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_15eventexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_14eventexec}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_16__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_9Eventhdlr_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_9Eventhdlr_18__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Eventhdlr[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_9Eventhdlr_model, __pyx_setprop_9pyscipopt_4scip_9Eventhdlr_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_9Eventhdlr_name, __pyx_setprop_9pyscipopt_4scip_9Eventhdlr_name, (char *)PyDoc_STR("name: unicode"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Eventhdlr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Eventhdlr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Eventhdlr}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Eventhdlr}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Eventhdlr}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Eventhdlr}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Eventhdlr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Eventhdlr_spec = { + "pyscipopt.scip.Eventhdlr", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Eventhdlr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Eventhdlr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Eventhdlr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Eventhdlr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Eventhdlr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Eventhdlr, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Eventhdlr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Eventhdlr, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Eventhdlr, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Eventhdlr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Heur(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Heur *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Heur *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Heur(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Heur *p = (struct __pyx_obj_9pyscipopt_4scip_Heur *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Heur) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Heur(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Heur *p = (struct __pyx_obj_9pyscipopt_4scip_Heur *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Heur(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Heur *p = (struct __pyx_obj_9pyscipopt_4scip_Heur *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_4Heur_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_4Heur_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_4Heur_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_4Heur_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_4Heur_5model_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_4Heur_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_4Heur_4name_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_4Heur_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_4Heur_4name_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_4Heur_4name_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Heur[] = { + {"heurfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_1heurfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_heurfree}, + {"heurinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_3heurinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_2heurinit}, + {"heurexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_5heurexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_4heurexit}, + {"heurinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_7heurinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_6heurinitsol}, + {"heurexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_9heurexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_8heurexitsol}, + {"heurexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_11heurexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_10heurexec}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_12__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Heur_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Heur_14__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Heur[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_4Heur_model, __pyx_setprop_9pyscipopt_4scip_4Heur_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_4Heur_name, __pyx_setprop_9pyscipopt_4scip_4Heur_name, (char *)PyDoc_STR("name: unicode"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Heur_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Heur}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Heur}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Heur}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Heur}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Heur}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Heur}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Heur_spec = { + "pyscipopt.scip.Heur", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Heur), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Heur_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Heur = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Heur", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Heur), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Heur, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Heur, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Heur, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Heur, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Heur, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Heur, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Presol(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Presol *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Presol *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Presol(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Presol *p = (struct __pyx_obj_9pyscipopt_4scip_Presol *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Presol) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Presol(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Presol *p = (struct __pyx_obj_9pyscipopt_4scip_Presol *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Presol(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Presol *p = (struct __pyx_obj_9pyscipopt_4scip_Presol *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_6Presol_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_6Presol_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_6Presol_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_6Presol_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_6Presol_5model_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Presol[] = { + {"presolfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_1presolfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_presolfree}, + {"presolinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_3presolinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_2presolinit}, + {"presolexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_5presolexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_4presolexit}, + {"presolinitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_7presolinitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_6presolinitpre}, + {"presolexitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_9presolexitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_8presolexitpre}, + {"presolexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_11presolexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_10presolexec}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_12__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Presol_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Presol_14__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Presol[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_6Presol_model, __pyx_setprop_9pyscipopt_4scip_6Presol_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Presol_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Presol}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Presol}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Presol}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Presol}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Presol}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Presol}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Presol_spec = { + "pyscipopt.scip.Presol", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Presol), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Presol_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Presol = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Presol", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Presol), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Presol, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Presol, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Presol, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Presol, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Presol, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Presol, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Pricer(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Pricer *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Pricer *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Pricer(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Pricer *p = (struct __pyx_obj_9pyscipopt_4scip_Pricer *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Pricer) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Pricer(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Pricer *p = (struct __pyx_obj_9pyscipopt_4scip_Pricer *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Pricer(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Pricer *p = (struct __pyx_obj_9pyscipopt_4scip_Pricer *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_6Pricer_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_6Pricer_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_6Pricer_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_6Pricer_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_6Pricer_5model_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Pricer[] = { + {"pricerfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_1pricerfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_pricerfree}, + {"pricerinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_3pricerinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_2pricerinit}, + {"pricerexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_5pricerexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_4pricerexit}, + {"pricerinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_7pricerinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_6pricerinitsol}, + {"pricerexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_9pricerexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_8pricerexitsol}, + {"pricerredcost", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_11pricerredcost, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_10pricerredcost}, + {"pricerfarkas", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_13pricerfarkas, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_12pricerfarkas}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_14__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Pricer_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Pricer_16__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Pricer[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_6Pricer_model, __pyx_setprop_9pyscipopt_4scip_6Pricer_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Pricer_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Pricer}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Pricer}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Pricer}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Pricer}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Pricer}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Pricer}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Pricer_spec = { + "pyscipopt.scip.Pricer", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Pricer), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Pricer_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Pricer = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Pricer", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Pricer), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Pricer, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Pricer, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Pricer, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Pricer, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Pricer, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Pricer, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Prop(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Prop *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Prop *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Prop(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Prop *p = (struct __pyx_obj_9pyscipopt_4scip_Prop *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Prop) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Prop(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Prop *p = (struct __pyx_obj_9pyscipopt_4scip_Prop *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Prop(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Prop *p = (struct __pyx_obj_9pyscipopt_4scip_Prop *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_4Prop_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_4Prop_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_4Prop_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_4Prop_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_4Prop_5model_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Prop[] = { + {"propfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_1propfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_propfree}, + {"propinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_3propinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_2propinit}, + {"propexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_5propexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_4propexit}, + {"propinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_7propinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_6propinitsol}, + {"propexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_9propexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_8propexitsol}, + {"propinitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_11propinitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_10propinitpre}, + {"propexitpre", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_13propexitpre, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_12propexitpre}, + {"proppresol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_15proppresol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_14proppresol}, + {"propexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_17propexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_16propexec}, + {"propresprop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_19propresprop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_18propresprop}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_21__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_20__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Prop_23__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Prop_22__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Prop[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_4Prop_model, __pyx_setprop_9pyscipopt_4scip_4Prop_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Prop_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Prop}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Prop}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Prop}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Prop}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Prop}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Prop}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Prop_spec = { + "pyscipopt.scip.Prop", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Prop), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Prop_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Prop = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Prop", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Prop), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Prop, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Prop, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Prop, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Prop, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Prop, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Prop, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Sepa(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Sepa *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Sepa *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Sepa(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Sepa *p = (struct __pyx_obj_9pyscipopt_4scip_Sepa *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Sepa) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Sepa(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Sepa *p = (struct __pyx_obj_9pyscipopt_4scip_Sepa *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Sepa(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Sepa *p = (struct __pyx_obj_9pyscipopt_4scip_Sepa *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_4Sepa_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_4Sepa_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_4Sepa_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_4Sepa_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_4Sepa_5model_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_4Sepa_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_4Sepa_4name_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_4Sepa_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_4Sepa_4name_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_4Sepa_4name_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Sepa[] = { + {"sepafree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_1sepafree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_sepafree}, + {"sepainit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_3sepainit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_2sepainit}, + {"sepaexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_5sepaexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_4sepaexit}, + {"sepainitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_7sepainitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_6sepainitsol}, + {"sepaexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_9sepaexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_8sepaexitsol}, + {"sepaexeclp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_11sepaexeclp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_10sepaexeclp}, + {"sepaexecsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_13sepaexecsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_12sepaexecsol}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_14__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_4Sepa_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_4Sepa_16__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Sepa[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_4Sepa_model, __pyx_setprop_9pyscipopt_4scip_4Sepa_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_4Sepa_name, __pyx_setprop_9pyscipopt_4scip_4Sepa_name, (char *)PyDoc_STR("name: unicode"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Sepa_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Sepa}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Sepa}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Sepa}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Sepa}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Sepa}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Sepa}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Sepa_spec = { + "pyscipopt.scip.Sepa", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Sepa), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Sepa_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Sepa = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Sepa", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Sepa), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Sepa, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Sepa, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Sepa, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Sepa, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Sepa, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Sepa, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Reader(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Reader *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Reader *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Reader(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Reader *p = (struct __pyx_obj_9pyscipopt_4scip_Reader *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Reader) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Reader(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Reader *p = (struct __pyx_obj_9pyscipopt_4scip_Reader *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Reader(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Reader *p = (struct __pyx_obj_9pyscipopt_4scip_Reader *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_6Reader_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_6Reader_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_6Reader_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_6Reader_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_6Reader_5model_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_6Reader_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_6Reader_4name_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_6Reader_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_6Reader_4name_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_6Reader_4name_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Reader[] = { + {"readerfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_1readerfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_readerfree}, + {"readerread", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_3readerread, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_2readerread}, + {"readerwrite", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_5readerwrite, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_4readerwrite}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_6__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_6Reader_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_6Reader_8__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Reader[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_6Reader_model, __pyx_setprop_9pyscipopt_4scip_6Reader_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_6Reader_name, __pyx_setprop_9pyscipopt_4scip_6Reader_name, (char *)PyDoc_STR("name: unicode"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Reader_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Reader}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Reader}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Reader}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Reader}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Reader}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Reader}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Reader_spec = { + "pyscipopt.scip.Reader", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Reader), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Reader_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Reader = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Reader", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Reader), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Reader, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Reader, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Reader, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Reader, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Reader, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Reader, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Relax(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Relax *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Relax *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Relax(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Relax *p = (struct __pyx_obj_9pyscipopt_4scip_Relax *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Relax) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + Py_CLEAR(p->name); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Relax(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Relax *p = (struct __pyx_obj_9pyscipopt_4scip_Relax *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Relax(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Relax *p = (struct __pyx_obj_9pyscipopt_4scip_Relax *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_5Relax_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_5Relax_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_5Relax_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_5Relax_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_5Relax_5model_5__del__(o); + } +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_5Relax_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_5Relax_4name_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_5Relax_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_5Relax_4name_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_5Relax_4name_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Relax[] = { + {"relaxfree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_1relaxfree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_relaxfree}, + {"relaxinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_3relaxinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_2relaxinit}, + {"relaxexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_5relaxexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_4relaxexit}, + {"relaxinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_7relaxinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_6relaxinitsol}, + {"relaxexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_9relaxexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_8relaxexitsol}, + {"relaxexec", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_11relaxexec, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_10relaxexec}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_12__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_5Relax_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_5Relax_14__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Relax[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_5Relax_model, __pyx_setprop_9pyscipopt_4scip_5Relax_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {(char *)"name", __pyx_getprop_9pyscipopt_4scip_5Relax_name, __pyx_setprop_9pyscipopt_4scip_5Relax_name, (char *)PyDoc_STR("name: unicode"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Relax_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Relax}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Relax}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Relax}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Relax}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Relax}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Relax}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Relax_spec = { + "pyscipopt.scip.Relax", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Relax), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Relax_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Relax = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Relax", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Relax), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Relax, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Relax, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Relax, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Relax, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Relax, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Relax, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_Nodesel(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_9pyscipopt_4scip_Nodesel *p; + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + p = ((struct __pyx_obj_9pyscipopt_4scip_Nodesel *)o); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_Nodesel(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip_Nodesel *p = (struct __pyx_obj_9pyscipopt_4scip_Nodesel *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_Nodesel) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->model); + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static int __pyx_tp_traverse_9pyscipopt_4scip_Nodesel(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *p = (struct __pyx_obj_9pyscipopt_4scip_Nodesel *)o; + if (p->model) { + e = (*v)(((PyObject *)p->model), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip_Nodesel(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip_Nodesel *p = (struct __pyx_obj_9pyscipopt_4scip_Nodesel *)o; + tmp = ((PyObject*)p->model); + p->model = ((struct __pyx_obj_9pyscipopt_4scip_Model *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_9pyscipopt_4scip_7Nodesel_model(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_9pyscipopt_4scip_7Nodesel_5model_1__get__(o); +} + +static int __pyx_setprop_9pyscipopt_4scip_7Nodesel_model(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_9pyscipopt_4scip_7Nodesel_5model_3__set__(o, v); + } + else { + return __pyx_pw_9pyscipopt_4scip_7Nodesel_5model_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_Nodesel[] = { + {"nodefree", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_1nodefree, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_nodefree}, + {"nodeinit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_3nodeinit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_2nodeinit}, + {"nodeexit", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_5nodeexit, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_4nodeexit}, + {"nodeinitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_7nodeinitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_6nodeinitsol}, + {"nodeexitsol", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_9nodeexitsol, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_8nodeexitsol}, + {"nodeselect", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_11nodeselect, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_10nodeselect}, + {"nodecomp", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_13nodecomp, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_12nodecomp}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_14__reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_7Nodesel_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_7Nodesel_16__setstate_cython__}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_9pyscipopt_4scip_Nodesel[] = { + {(char *)"model", __pyx_getprop_9pyscipopt_4scip_7Nodesel_model, __pyx_setprop_9pyscipopt_4scip_7Nodesel_model, (char *)PyDoc_STR("model: pyscipopt.scip.Model"), 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_Nodesel_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_Nodesel}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip_Nodesel}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip_Nodesel}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_Nodesel}, + {Py_tp_getset, (void *)__pyx_getsets_9pyscipopt_4scip_Nodesel}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_Nodesel}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_Nodesel_spec = { + "pyscipopt.scip.Nodesel", + sizeof(struct __pyx_obj_9pyscipopt_4scip_Nodesel), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_9pyscipopt_4scip_Nodesel_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_Nodesel = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""Nodesel", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_Nodesel), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_Nodesel, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip_Nodesel, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip_Nodesel, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_Nodesel, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_9pyscipopt_4scip_Nodesel, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_Nodesel, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_RESULT(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_RESULT(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_RESULT) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_RESULT[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_14PY_SCIP_RESULT_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14PY_SCIP_RESULT___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_14PY_SCIP_RESULT_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14PY_SCIP_RESULT_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_RESULT}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_RESULT}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_RESULT}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT_spec = { + "pyscipopt.scip.PY_SCIP_RESULT", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_RESULT", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_RESULT), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_RESULT, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_RESULT, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_RESULT, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PARAMSETTING(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PARAMSETTING(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PARAMSETTING) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_PARAMSETTING[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PARAMSETTING}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_PARAMSETTING}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PARAMSETTING}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING_spec = { + "pyscipopt.scip.PY_SCIP_PARAMSETTING", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_PARAMSETTING", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMSETTING), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS_spec = { + "pyscipopt.scip.PY_SCIP_PARAMEMPHASIS", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_PARAMEMPHASIS", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_STATUS(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_STATUS(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_STATUS) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_STATUS[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_14PY_SCIP_STATUS_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14PY_SCIP_STATUS___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_14PY_SCIP_STATUS_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_14PY_SCIP_STATUS_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_STATUS}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_STATUS}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_STATUS}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS_spec = { + "pyscipopt.scip.PY_SCIP_STATUS", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_STATUS", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STATUS), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_STATUS, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_STATUS, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_STATUS, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_STAGE(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_STAGE(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_STAGE) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_STAGE[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13PY_SCIP_STAGE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13PY_SCIP_STAGE___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_13PY_SCIP_STAGE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_13PY_SCIP_STAGE_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_STAGE}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_STAGE}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_STAGE}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE_spec = { + "pyscipopt.scip.PY_SCIP_STAGE", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_STAGE", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_STAGE), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_STAGE, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_STAGE, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_STAGE, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_NODETYPE(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_NODETYPE(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_NODETYPE) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_NODETYPE[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_16PY_SCIP_NODETYPE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_16PY_SCIP_NODETYPE___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_16PY_SCIP_NODETYPE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_16PY_SCIP_NODETYPE_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_NODETYPE}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_NODETYPE}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_NODETYPE}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE_spec = { + "pyscipopt.scip.PY_SCIP_NODETYPE", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_NODETYPE", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_NODETYPE), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_NODETYPE, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_NODETYPE, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_NODETYPE, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PROPTIMING(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PROPTIMING(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PROPTIMING) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_PROPTIMING[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18PY_SCIP_PROPTIMING___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PROPTIMING}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_PROPTIMING}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PROPTIMING}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING_spec = { + "pyscipopt.scip.PY_SCIP_PROPTIMING", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_PROPTIMING", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PROPTIMING), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PROPTIMING, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_PROPTIMING, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PROPTIMING, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING_spec = { + "pyscipopt.scip.PY_SCIP_PRESOLTIMING", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_PRESOLTIMING", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_HEURTIMING(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_HEURTIMING(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_HEURTIMING) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_HEURTIMING[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18PY_SCIP_HEURTIMING___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_HEURTIMING}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_HEURTIMING}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_HEURTIMING}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING_spec = { + "pyscipopt.scip.PY_SCIP_HEURTIMING", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_HEURTIMING", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_HEURTIMING), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_HEURTIMING, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_HEURTIMING, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_HEURTIMING, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_EVENTTYPE(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_EVENTTYPE(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_EVENTTYPE) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_EVENTTYPE[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_EVENTTYPE}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_EVENTTYPE}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_EVENTTYPE}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE_spec = { + "pyscipopt.scip.PY_SCIP_EVENTTYPE", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_EVENTTYPE", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_EVENTTYPE), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT_spec = { + "pyscipopt.scip.PY_SCIP_LPSOLSTAT", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_LPSOLSTAT", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_BRANCHDIR(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_BRANCHDIR(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_BRANCHDIR) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_BRANCHDIR[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_BRANCHDIR}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_BRANCHDIR}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_BRANCHDIR}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR_spec = { + "pyscipopt.scip.PY_SCIP_BRANCHDIR", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_BRANCHDIR", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BRANCHDIR), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE_spec = { + "pyscipopt.scip.PY_SCIP_BENDERSENFOTYPE", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_BENDERSENFOTYPE", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif +} + +static PyMethodDef __pyx_methods_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE[] = { + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE___reduce_cython__}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_2__setstate_cython__}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE}, + {Py_tp_methods, (void *)__pyx_methods_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE_spec = { + "pyscipopt.scip.PY_SCIP_ROWORIGINTYPE", + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""PY_SCIP_ROWORIGINTYPE", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct__genexpr[8]; +static int __pyx_freecount_9pyscipopt_4scip___pyx_scope_struct__genexpr = 0; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct__genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct__genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr)))) { + o = (PyObject*)__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct__genexpr[--__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct__genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct__genexpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct__genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_v); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct__genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr)))) { + __pyx_freelist_9pyscipopt_4scip___pyx_scope_struct__genexpr[__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct__genexpr++] = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct__genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr *)o; + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_v) { + e = (*v)(p->__pyx_v_v, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct__genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct__genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct__genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr_spec = { + "pyscipopt.scip.__pyx_scope_struct__genexpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""__pyx_scope_struct__genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct__genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct__genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct__genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct__genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_1_genexpr[8]; +static int __pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_1_genexpr = 0; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_1_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr)))) { + o = (PyObject*)__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_1_genexpr[--__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_1_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_1_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_v); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_1_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr)))) { + __pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_1_genexpr[__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr *)o; + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_v) { + e = (*v)(p->__pyx_v_v, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_1_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_1_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_1_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr_spec = { + "pyscipopt.scip.__pyx_scope_struct_1_genexpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_1_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_2_genexpr[8]; +static int __pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_2_genexpr = 0; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_2_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_2_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr)))) { + o = (PyObject*)__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_2_genexpr[--__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_2_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_2_genexpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_2_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_entries); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_2_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr)))) { + __pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_2_genexpr[__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_2_genexpr++] = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_2_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr *)o; + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_entries) { + e = (*v)(p->__pyx_v_entries, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_2_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_2_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_2_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr_spec = { + "pyscipopt.scip.__pyx_scope_struct_2_genexpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""__pyx_scope_struct_2_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_2_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_2_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_2_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_2_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_3_genexpr[8]; +static int __pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_3_genexpr = 0; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_3_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_3_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr)))) { + o = (PyObject*)__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_3_genexpr[--__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_3_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_3_genexpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_3_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_entries); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_3_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr)))) { + __pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_3_genexpr[__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_3_genexpr++] = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_3_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr *)o; + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_entries) { + e = (*v)(p->__pyx_v_entries, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_3_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_3_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_3_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr_spec = { + "pyscipopt.scip.__pyx_scope_struct_3_genexpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""__pyx_scope_struct_3_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_3_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_3_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_3_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_3_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_4___getitem__[8]; +static int __pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ = 0; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_4___getitem__(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__)))) { + o = (PyObject*)__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_4___getitem__[--__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_4___getitem__]; + memset(o, 0, sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_4___getitem__(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_4___getitem__) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_self); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__)))) { + __pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_4___getitem__[__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_4___getitem__++] = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_4___getitem__(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *)o; + if (p->__pyx_v_self) { + e = (*v)(((PyObject *)p->__pyx_v_self), a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_9pyscipopt_4scip___pyx_scope_struct_4___getitem__(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ *)o; + tmp = ((PyObject*)p->__pyx_v_self); + p->__pyx_v_self = ((struct __pyx_obj_9pyscipopt_4scip_Solution *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem___slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_4___getitem__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_4___getitem__}, + {Py_tp_clear, (void *)__pyx_tp_clear_9pyscipopt_4scip___pyx_scope_struct_4___getitem__}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_4___getitem__}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem___spec = { + "pyscipopt.scip.__pyx_scope_struct_4___getitem__", + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem___slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""__pyx_scope_struct_4___getitem__", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_4___getitem__), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_4___getitem__, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_4___getitem__, /*tp_traverse*/ + __pyx_tp_clear_9pyscipopt_4scip___pyx_scope_struct_4___getitem__, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_4___getitem__, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +#if CYTHON_USE_FREELISTS +static struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_5_genexpr[8]; +static int __pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_5_genexpr = 0; +#endif + +static PyObject *__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_5_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_5_genexpr > 0) & (int)(t->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr)))) { + o = (PyObject*)__pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_5_genexpr[--__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_5_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else + #endif + { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + #endif + return o; +} + +static void __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_5_genexpr(PyObject *o) { + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_5_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_coeff); + Py_CLEAR(p->__pyx_v_term); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (((int)(__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_5_genexpr < 8) & (int)(Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr)))) { + __pyx_freelist_9pyscipopt_4scip___pyx_scope_struct_5_genexpr[__pyx_freecount_9pyscipopt_4scip___pyx_scope_struct_5_genexpr++] = ((struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *)o); + } else + #endif + { + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + } +} + +static int __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_5_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *p = (struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject *)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_coeff) { + e = (*v)(p->__pyx_v_coeff, a); if (e) return e; + } + if (p->__pyx_v_term) { + e = (*v)(p->__pyx_v_term, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_5_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_5_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_5_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr_spec = { + "pyscipopt.scip.__pyx_scope_struct_5_genexpr", + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, + __pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "pyscipopt.scip.""__pyx_scope_struct_5_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_9pyscipopt_4scip___pyx_scope_struct_5_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_9pyscipopt_4scip___pyx_scope_struct_5_genexpr, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_9pyscipopt_4scip___pyx_scope_struct_5_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_9pyscipopt_4scip___pyx_scope_struct_5_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_AFTERLPLOOP, __pyx_k_AFTERLPLOOP, sizeof(__pyx_k_AFTERLPLOOP), 0, 0, 1, 1}, + {&__pyx_n_s_AFTERLPNODE, __pyx_k_AFTERLPNODE, sizeof(__pyx_k_AFTERLPNODE), 0, 0, 1, 1}, + {&__pyx_n_s_AFTERLPPLUNGE, __pyx_k_AFTERLPPLUNGE, sizeof(__pyx_k_AFTERLPPLUNGE), 0, 0, 1, 1}, + {&__pyx_n_s_AFTERPROPLOOP, __pyx_k_AFTERPROPLOOP, sizeof(__pyx_k_AFTERPROPLOOP), 0, 0, 1, 1}, + {&__pyx_n_s_AFTERPSEUDONODE, __pyx_k_AFTERPSEUDONODE, sizeof(__pyx_k_AFTERPSEUDONODE), 0, 0, 1, 1}, + {&__pyx_n_s_AFTERPSEUDOPLUNGE, __pyx_k_AFTERPSEUDOPLUNGE, sizeof(__pyx_k_AFTERPSEUDOPLUNGE), 0, 0, 1, 1}, + {&__pyx_n_s_AGGRESSIVE, __pyx_k_AGGRESSIVE, sizeof(__pyx_k_AGGRESSIVE), 0, 0, 1, 1}, + {&__pyx_n_u_ANDcons, __pyx_k_ANDcons, sizeof(__pyx_k_ANDcons), 0, 1, 0, 1}, + {&__pyx_n_s_AUTO, __pyx_k_AUTO, sizeof(__pyx_k_AUTO), 0, 0, 1, 1}, + {&__pyx_n_s_AssertionError, __pyx_k_AssertionError, sizeof(__pyx_k_AssertionError), 0, 0, 1, 1}, + {&__pyx_n_u_B, __pyx_k_B, sizeof(__pyx_k_B), 0, 1, 0, 1}, + {&__pyx_n_s_BEFORELP, __pyx_k_BEFORELP, sizeof(__pyx_k_BEFORELP), 0, 0, 1, 1}, + {&__pyx_n_s_BEFORENODE, __pyx_k_BEFORENODE, sizeof(__pyx_k_BEFORENODE), 0, 0, 1, 1}, + {&__pyx_n_s_BEFOREPRESOL, __pyx_k_BEFOREPRESOL, sizeof(__pyx_k_BEFOREPRESOL), 0, 0, 1, 1}, + {&__pyx_n_s_BENCHMARK, __pyx_k_BENCHMARK, sizeof(__pyx_k_BENCHMARK), 0, 0, 1, 1}, + {&__pyx_n_s_BESTSOLFOUND, __pyx_k_BESTSOLFOUND, sizeof(__pyx_k_BESTSOLFOUND), 0, 0, 1, 1}, + {&__pyx_n_s_BESTSOLLIMIT, __pyx_k_BESTSOLLIMIT, sizeof(__pyx_k_BESTSOLLIMIT), 0, 0, 1, 1}, + {&__pyx_n_u_BINARY, __pyx_k_BINARY, sizeof(__pyx_k_BINARY), 0, 1, 0, 1}, + {&__pyx_n_s_BOUNDCHANGED, __pyx_k_BOUNDCHANGED, sizeof(__pyx_k_BOUNDCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_BOUNDRELAXED, __pyx_k_BOUNDRELAXED, sizeof(__pyx_k_BOUNDRELAXED), 0, 0, 1, 1}, + {&__pyx_n_s_BOUNDTIGHTENED, __pyx_k_BOUNDTIGHTENED, sizeof(__pyx_k_BOUNDTIGHTENED), 0, 0, 1, 1}, + {&__pyx_n_s_BRANCHED, __pyx_k_BRANCHED, sizeof(__pyx_k_BRANCHED), 0, 0, 1, 1}, + {&__pyx_n_s_Benders, __pyx_k_Benders, sizeof(__pyx_k_Benders), 0, 0, 1, 1}, + {&__pyx_n_s_Benders___reduce_cython, __pyx_k_Benders___reduce_cython, sizeof(__pyx_k_Benders___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Benders___setstate_cython, __pyx_k_Benders___setstate_cython, sizeof(__pyx_k_Benders___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_benderscreatesub, __pyx_k_Benders_benderscreatesub, sizeof(__pyx_k_Benders_benderscreatesub), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersexit, __pyx_k_Benders_bendersexit, sizeof(__pyx_k_Benders_bendersexit), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersexitpre, __pyx_k_Benders_bendersexitpre, sizeof(__pyx_k_Benders_bendersexitpre), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersexitsol, __pyx_k_Benders_bendersexitsol, sizeof(__pyx_k_Benders_bendersexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersfree, __pyx_k_Benders_bendersfree, sizeof(__pyx_k_Benders_bendersfree), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersfreesub, __pyx_k_Benders_bendersfreesub, sizeof(__pyx_k_Benders_bendersfreesub), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersgetvar, __pyx_k_Benders_bendersgetvar, sizeof(__pyx_k_Benders_bendersgetvar), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersinit, __pyx_k_Benders_bendersinit, sizeof(__pyx_k_Benders_bendersinit), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersinitpre, __pyx_k_Benders_bendersinitpre, sizeof(__pyx_k_Benders_bendersinitpre), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_bendersinitsol, __pyx_k_Benders_bendersinitsol, sizeof(__pyx_k_Benders_bendersinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_benderspostsolve, __pyx_k_Benders_benderspostsolve, sizeof(__pyx_k_Benders_benderspostsolve), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_benderspresubsolve, __pyx_k_Benders_benderspresubsolve, sizeof(__pyx_k_Benders_benderspresubsolve), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_benderssolvesub, __pyx_k_Benders_benderssolvesub, sizeof(__pyx_k_Benders_benderssolvesub), 0, 0, 1, 1}, + {&__pyx_n_s_Benders_benderssolvesubconvex, __pyx_k_Benders_benderssolvesubconvex, sizeof(__pyx_k_Benders_benderssolvesubconvex), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut, __pyx_k_Benderscut, sizeof(__pyx_k_Benderscut), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut___reduce_cython, __pyx_k_Benderscut___reduce_cython, sizeof(__pyx_k_Benderscut___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut___setstate_cython, __pyx_k_Benderscut___setstate_cython, sizeof(__pyx_k_Benderscut___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut_benderscutexec, __pyx_k_Benderscut_benderscutexec, sizeof(__pyx_k_Benderscut_benderscutexec), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut_benderscutexit, __pyx_k_Benderscut_benderscutexit, sizeof(__pyx_k_Benderscut_benderscutexit), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut_benderscutexitsol, __pyx_k_Benderscut_benderscutexitsol, sizeof(__pyx_k_Benderscut_benderscutexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut_benderscutfree, __pyx_k_Benderscut_benderscutfree, sizeof(__pyx_k_Benderscut_benderscutfree), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut_benderscutinit, __pyx_k_Benderscut_benderscutinit, sizeof(__pyx_k_Benderscut_benderscutinit), 0, 0, 1, 1}, + {&__pyx_n_s_Benderscut_benderscutinitsol, __pyx_k_Benderscut_benderscutinitsol, sizeof(__pyx_k_Benderscut_benderscutinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_BoundChange, __pyx_k_BoundChange, sizeof(__pyx_k_BoundChange), 0, 0, 1, 1}, + {&__pyx_n_s_BoundChange___reduce_cython, __pyx_k_BoundChange___reduce_cython, sizeof(__pyx_k_BoundChange___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_BoundChange___setstate_cython, __pyx_k_BoundChange___setstate_cython, sizeof(__pyx_k_BoundChange___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_BoundChange_getBoundchgtype, __pyx_k_BoundChange_getBoundchgtype, sizeof(__pyx_k_BoundChange_getBoundchgtype), 0, 0, 1, 1}, + {&__pyx_n_s_BoundChange_getBoundtype, __pyx_k_BoundChange_getBoundtype, sizeof(__pyx_k_BoundChange_getBoundtype), 0, 0, 1, 1}, + {&__pyx_n_s_BoundChange_getNewBound, __pyx_k_BoundChange_getNewBound, sizeof(__pyx_k_BoundChange_getNewBound), 0, 0, 1, 1}, + {&__pyx_n_s_BoundChange_getVar, __pyx_k_BoundChange_getVar, sizeof(__pyx_k_BoundChange_getVar), 0, 0, 1, 1}, + {&__pyx_n_s_BoundChange_isRedundant, __pyx_k_BoundChange_isRedundant, sizeof(__pyx_k_BoundChange_isRedundant), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule, __pyx_k_Branchrule, sizeof(__pyx_k_Branchrule), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule___reduce_cython, __pyx_k_Branchrule___reduce_cython, sizeof(__pyx_k_Branchrule___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule___setstate_cython, __pyx_k_Branchrule___setstate_cython, sizeof(__pyx_k_Branchrule___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule_branchexecext, __pyx_k_Branchrule_branchexecext, sizeof(__pyx_k_Branchrule_branchexecext), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule_branchexeclp, __pyx_k_Branchrule_branchexeclp, sizeof(__pyx_k_Branchrule_branchexeclp), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule_branchexecps, __pyx_k_Branchrule_branchexecps, sizeof(__pyx_k_Branchrule_branchexecps), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule_branchexit, __pyx_k_Branchrule_branchexit, sizeof(__pyx_k_Branchrule_branchexit), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule_branchexitsol, __pyx_k_Branchrule_branchexitsol, sizeof(__pyx_k_Branchrule_branchexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule_branchfree, __pyx_k_Branchrule_branchfree, sizeof(__pyx_k_Branchrule_branchfree), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule_branchinit, __pyx_k_Branchrule_branchinit, sizeof(__pyx_k_Branchrule_branchinit), 0, 0, 1, 1}, + {&__pyx_n_s_Branchrule_branchinitsol, __pyx_k_Branchrule_branchinitsol, sizeof(__pyx_k_Branchrule_branchinitsol), 0, 0, 1, 1}, + {&__pyx_n_u_C, __pyx_k_C, sizeof(__pyx_k_C), 0, 1, 0, 1}, + {&__pyx_n_s_CHECK, __pyx_k_CHECK, sizeof(__pyx_k_CHECK), 0, 0, 1, 1}, + {&__pyx_n_s_CHILD, __pyx_k_CHILD, sizeof(__pyx_k_CHILD), 0, 0, 1, 1}, + {&__pyx_n_s_CONS, __pyx_k_CONS, sizeof(__pyx_k_CONS), 0, 0, 1, 1}, + {&__pyx_n_s_CONSADDED, __pyx_k_CONSADDED, sizeof(__pyx_k_CONSADDED), 0, 0, 1, 1}, + {&__pyx_n_s_CONSCHANGED, __pyx_k_CONSCHANGED, sizeof(__pyx_k_CONSCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_CONST, __pyx_k_CONST, sizeof(__pyx_k_CONST), 0, 0, 1, 1}, + {&__pyx_n_u_CONTINUOUS, __pyx_k_CONTINUOUS, sizeof(__pyx_k_CONTINUOUS), 0, 1, 0, 1}, + {&__pyx_n_s_COUNTER, __pyx_k_COUNTER, sizeof(__pyx_k_COUNTER), 0, 0, 1, 1}, + {&__pyx_n_s_CPSOLVER, __pyx_k_CPSOLVER, sizeof(__pyx_k_CPSOLVER), 0, 0, 1, 1}, + {&__pyx_n_s_CUTOFF, __pyx_k_CUTOFF, sizeof(__pyx_k_CUTOFF), 0, 0, 1, 1}, + {&__pyx_kp_u_Can_only_support_constraints_wit, __pyx_k_Can_only_support_constraints_wit, sizeof(__pyx_k_Can_only_support_constraints_wit), 0, 1, 0, 0}, + {&__pyx_kp_u_Can_t_evaluate_constraints_as_bo, __pyx_k_Can_t_evaluate_constraints_as_bo, sizeof(__pyx_k_Can_t_evaluate_constraints_as_bo), 0, 1, 0, 0}, + {&__pyx_kp_u_Cannot_set_value_to_a_freed_solu, __pyx_k_Cannot_set_value_to_a_freed_solu, sizeof(__pyx_k_Cannot_set_value_to_a_freed_solu), 0, 1, 0, 0}, + {&__pyx_n_u_CardinalityCons, __pyx_k_CardinalityCons, sizeof(__pyx_k_CardinalityCons), 0, 1, 0, 1}, + {&__pyx_n_s_Column, __pyx_k_Column, sizeof(__pyx_k_Column), 0, 0, 1, 1}, + {&__pyx_n_s_Column___reduce_cython, __pyx_k_Column___reduce_cython, sizeof(__pyx_k_Column___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Column___setstate_cython, __pyx_k_Column___setstate_cython, sizeof(__pyx_k_Column___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Column_getBasisStatus, __pyx_k_Column_getBasisStatus, sizeof(__pyx_k_Column_getBasisStatus), 0, 0, 1, 1}, + {&__pyx_n_s_Column_getLPPos, __pyx_k_Column_getLPPos, sizeof(__pyx_k_Column_getLPPos), 0, 0, 1, 1}, + {&__pyx_n_s_Column_getLb, __pyx_k_Column_getLb, sizeof(__pyx_k_Column_getLb), 0, 0, 1, 1}, + {&__pyx_n_s_Column_getObjCoeff, __pyx_k_Column_getObjCoeff, sizeof(__pyx_k_Column_getObjCoeff), 0, 0, 1, 1}, + {&__pyx_n_s_Column_getPrimsol, __pyx_k_Column_getPrimsol, sizeof(__pyx_k_Column_getPrimsol), 0, 0, 1, 1}, + {&__pyx_n_s_Column_getUb, __pyx_k_Column_getUb, sizeof(__pyx_k_Column_getUb), 0, 0, 1, 1}, + {&__pyx_n_s_Column_getVar, __pyx_k_Column_getVar, sizeof(__pyx_k_Column_getVar), 0, 0, 1, 1}, + {&__pyx_n_s_Column_isIntegral, __pyx_k_Column_isIntegral, sizeof(__pyx_k_Column_isIntegral), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr, __pyx_k_Conshdlr, sizeof(__pyx_k_Conshdlr), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr___reduce_cython, __pyx_k_Conshdlr___reduce_cython, sizeof(__pyx_k_Conshdlr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr___setstate_cython, __pyx_k_Conshdlr___setstate_cython, sizeof(__pyx_k_Conshdlr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consactive, __pyx_k_Conshdlr_consactive, sizeof(__pyx_k_Conshdlr_consactive), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_conscheck, __pyx_k_Conshdlr_conscheck, sizeof(__pyx_k_Conshdlr_conscheck), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_conscopy, __pyx_k_Conshdlr_conscopy, sizeof(__pyx_k_Conshdlr_conscopy), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consdeactive, __pyx_k_Conshdlr_consdeactive, sizeof(__pyx_k_Conshdlr_consdeactive), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consdelete, __pyx_k_Conshdlr_consdelete, sizeof(__pyx_k_Conshdlr_consdelete), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consdelvars, __pyx_k_Conshdlr_consdelvars, sizeof(__pyx_k_Conshdlr_consdelvars), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consdisable, __pyx_k_Conshdlr_consdisable, sizeof(__pyx_k_Conshdlr_consdisable), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consenable, __pyx_k_Conshdlr_consenable, sizeof(__pyx_k_Conshdlr_consenable), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consenfolp, __pyx_k_Conshdlr_consenfolp, sizeof(__pyx_k_Conshdlr_consenfolp), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consenfops, __pyx_k_Conshdlr_consenfops, sizeof(__pyx_k_Conshdlr_consenfops), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consenforelax, __pyx_k_Conshdlr_consenforelax, sizeof(__pyx_k_Conshdlr_consenforelax), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consexit, __pyx_k_Conshdlr_consexit, sizeof(__pyx_k_Conshdlr_consexit), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consexitpre, __pyx_k_Conshdlr_consexitpre, sizeof(__pyx_k_Conshdlr_consexitpre), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consexitsol, __pyx_k_Conshdlr_consexitsol, sizeof(__pyx_k_Conshdlr_consexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consfree, __pyx_k_Conshdlr_consfree, sizeof(__pyx_k_Conshdlr_consfree), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consgetdivebdchgs, __pyx_k_Conshdlr_consgetdivebdchgs, sizeof(__pyx_k_Conshdlr_consgetdivebdchgs), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consgetnvars, __pyx_k_Conshdlr_consgetnvars, sizeof(__pyx_k_Conshdlr_consgetnvars), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consgetpermsymgraph, __pyx_k_Conshdlr_consgetpermsymgraph, sizeof(__pyx_k_Conshdlr_consgetpermsymgraph), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consgetsignedpermsymgra, __pyx_k_Conshdlr_consgetsignedpermsymgra, sizeof(__pyx_k_Conshdlr_consgetsignedpermsymgra), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consgetvars, __pyx_k_Conshdlr_consgetvars, sizeof(__pyx_k_Conshdlr_consgetvars), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consinit, __pyx_k_Conshdlr_consinit, sizeof(__pyx_k_Conshdlr_consinit), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consinitlp, __pyx_k_Conshdlr_consinitlp, sizeof(__pyx_k_Conshdlr_consinitlp), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consinitpre, __pyx_k_Conshdlr_consinitpre, sizeof(__pyx_k_Conshdlr_consinitpre), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consinitsol, __pyx_k_Conshdlr_consinitsol, sizeof(__pyx_k_Conshdlr_consinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_conslock, __pyx_k_Conshdlr_conslock, sizeof(__pyx_k_Conshdlr_conslock), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consparse, __pyx_k_Conshdlr_consparse, sizeof(__pyx_k_Conshdlr_consparse), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_conspresol, __pyx_k_Conshdlr_conspresol, sizeof(__pyx_k_Conshdlr_conspresol), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consprint, __pyx_k_Conshdlr_consprint, sizeof(__pyx_k_Conshdlr_consprint), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consprop, __pyx_k_Conshdlr_consprop, sizeof(__pyx_k_Conshdlr_consprop), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_consresprop, __pyx_k_Conshdlr_consresprop, sizeof(__pyx_k_Conshdlr_consresprop), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_conssepalp, __pyx_k_Conshdlr_conssepalp, sizeof(__pyx_k_Conshdlr_conssepalp), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_conssepasol, __pyx_k_Conshdlr_conssepasol, sizeof(__pyx_k_Conshdlr_conssepasol), 0, 0, 1, 1}, + {&__pyx_n_s_Conshdlr_constrans, __pyx_k_Conshdlr_constrans, sizeof(__pyx_k_Conshdlr_constrans), 0, 0, 1, 1}, + {&__pyx_n_s_Constant, __pyx_k_Constant, sizeof(__pyx_k_Constant), 0, 0, 1, 1}, + {&__pyx_n_s_Constant___reduce_cython, __pyx_k_Constant___reduce_cython, sizeof(__pyx_k_Constant___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Constant___setstate_cython, __pyx_k_Constant___setstate_cython, sizeof(__pyx_k_Constant___setstate_cython), 0, 0, 1, 1}, + {&__pyx_kp_u_Constant_offsets_in_objective_ar, __pyx_k_Constant_offsets_in_objective_ar, sizeof(__pyx_k_Constant_offsets_in_objective_ar), 0, 1, 0, 0}, + {&__pyx_n_s_Constraint, __pyx_k_Constraint, sizeof(__pyx_k_Constraint), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint___reduce_cython, __pyx_k_Constraint___reduce_cython, sizeof(__pyx_k_Constraint___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint___setstate_cython, __pyx_k_Constraint___setstate_cython, sizeof(__pyx_k_Constraint___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_getConshdlrName, __pyx_k_Constraint_getConshdlrName, sizeof(__pyx_k_Constraint_getConshdlrName), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isActive, __pyx_k_Constraint_isActive, sizeof(__pyx_k_Constraint_isActive), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isChecked, __pyx_k_Constraint_isChecked, sizeof(__pyx_k_Constraint_isChecked), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isDynamic, __pyx_k_Constraint_isDynamic, sizeof(__pyx_k_Constraint_isDynamic), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isEnforced, __pyx_k_Constraint_isEnforced, sizeof(__pyx_k_Constraint_isEnforced), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isInitial, __pyx_k_Constraint_isInitial, sizeof(__pyx_k_Constraint_isInitial), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isLinear, __pyx_k_Constraint_isLinear, sizeof(__pyx_k_Constraint_isLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isLocal, __pyx_k_Constraint_isLocal, sizeof(__pyx_k_Constraint_isLocal), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isModifiable, __pyx_k_Constraint_isModifiable, sizeof(__pyx_k_Constraint_isModifiable), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isNonlinear, __pyx_k_Constraint_isNonlinear, sizeof(__pyx_k_Constraint_isNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isOriginal, __pyx_k_Constraint_isOriginal, sizeof(__pyx_k_Constraint_isOriginal), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isPropagated, __pyx_k_Constraint_isPropagated, sizeof(__pyx_k_Constraint_isPropagated), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isRemovable, __pyx_k_Constraint_isRemovable, sizeof(__pyx_k_Constraint_isRemovable), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isSeparated, __pyx_k_Constraint_isSeparated, sizeof(__pyx_k_Constraint_isSeparated), 0, 0, 1, 1}, + {&__pyx_n_s_Constraint_isStickingAtNode, __pyx_k_Constraint_isStickingAtNode, sizeof(__pyx_k_Constraint_isStickingAtNode), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel, __pyx_k_Cutsel, sizeof(__pyx_k_Cutsel), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel___reduce_cython, __pyx_k_Cutsel___reduce_cython, sizeof(__pyx_k_Cutsel___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel___setstate_cython, __pyx_k_Cutsel___setstate_cython, sizeof(__pyx_k_Cutsel___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel_cutselexit, __pyx_k_Cutsel_cutselexit, sizeof(__pyx_k_Cutsel_cutselexit), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel_cutselexitsol, __pyx_k_Cutsel_cutselexitsol, sizeof(__pyx_k_Cutsel_cutselexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel_cutselfree, __pyx_k_Cutsel_cutselfree, sizeof(__pyx_k_Cutsel_cutselfree), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel_cutselinit, __pyx_k_Cutsel_cutselinit, sizeof(__pyx_k_Cutsel_cutselinit), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel_cutselinitsol, __pyx_k_Cutsel_cutselinitsol, sizeof(__pyx_k_Cutsel_cutselinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Cutsel_cutselselect, __pyx_k_Cutsel_cutselselect, sizeof(__pyx_k_Cutsel_cutselselect), 0, 0, 1, 1}, + {&__pyx_n_s_DEADEND, __pyx_k_DEADEND, sizeof(__pyx_k_DEADEND), 0, 0, 1, 1}, + {&__pyx_n_s_DEFAULT, __pyx_k_DEFAULT, sizeof(__pyx_k_DEFAULT), 0, 0, 1, 1}, + {&__pyx_n_s_DELAYED, __pyx_k_DELAYED, sizeof(__pyx_k_DELAYED), 0, 0, 1, 1}, + {&__pyx_n_s_DIDNOTFIND, __pyx_k_DIDNOTFIND, sizeof(__pyx_k_DIDNOTFIND), 0, 0, 1, 1}, + {&__pyx_n_s_DIDNOTRUN, __pyx_k_DIDNOTRUN, sizeof(__pyx_k_DIDNOTRUN), 0, 0, 1, 1}, + {&__pyx_n_s_DISABLED, __pyx_k_DISABLED, sizeof(__pyx_k_DISABLED), 0, 0, 1, 1}, + {&__pyx_n_s_DOMCHANGED, __pyx_k_DOMCHANGED, sizeof(__pyx_k_DOMCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_DOWNWARDS, __pyx_k_DOWNWARDS, sizeof(__pyx_k_DOWNWARDS), 0, 0, 1, 1}, + {&__pyx_n_s_DUALLIMIT, __pyx_k_DUALLIMIT, sizeof(__pyx_k_DUALLIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_DURINGLPLOOP, __pyx_k_DURINGLPLOOP, sizeof(__pyx_k_DURINGLPLOOP), 0, 0, 1, 1}, + {&__pyx_n_s_DURINGPRESOLLOOP, __pyx_k_DURINGPRESOLLOOP, sizeof(__pyx_k_DURINGPRESOLLOOP), 0, 0, 1, 1}, + {&__pyx_n_s_DURINGPRICINGLOOP, __pyx_k_DURINGPRICINGLOOP, sizeof(__pyx_k_DURINGPRICINGLOOP), 0, 0, 1, 1}, + {&__pyx_n_s_DomainChanges, __pyx_k_DomainChanges, sizeof(__pyx_k_DomainChanges), 0, 0, 1, 1}, + {&__pyx_n_s_DomainChanges___reduce_cython, __pyx_k_DomainChanges___reduce_cython, sizeof(__pyx_k_DomainChanges___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_DomainChanges___setstate_cython, __pyx_k_DomainChanges___setstate_cython, sizeof(__pyx_k_DomainChanges___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_DomainChanges_getBoundchgs, __pyx_k_DomainChanges_getBoundchgs, sizeof(__pyx_k_DomainChanges_getBoundchgs), 0, 0, 1, 1}, + {&__pyx_n_s_EASYCIP, __pyx_k_EASYCIP, sizeof(__pyx_k_EASYCIP), 0, 0, 1, 1}, + {&__pyx_n_s_ERROR, __pyx_k_ERROR, sizeof(__pyx_k_ERROR), 0, 0, 1, 1}, + {&__pyx_n_s_EXHAUSTIVE, __pyx_k_EXHAUSTIVE, sizeof(__pyx_k_EXHAUSTIVE), 0, 0, 1, 1}, + {&__pyx_n_s_EXITPRESOLVE, __pyx_k_EXITPRESOLVE, sizeof(__pyx_k_EXITPRESOLVE), 0, 0, 1, 1}, + {&__pyx_n_s_EXITSOLVE, __pyx_k_EXITSOLVE, sizeof(__pyx_k_EXITSOLVE), 0, 0, 1, 1}, + {&__pyx_n_s_Event, __pyx_k_Event, sizeof(__pyx_k_Event), 0, 0, 1, 1}, + {&__pyx_n_s_EventNames, __pyx_k_EventNames, sizeof(__pyx_k_EventNames), 0, 0, 1, 1}, + {&__pyx_n_s_Event___reduce_cython, __pyx_k_Event___reduce_cython, sizeof(__pyx_k_Event___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Event___setstate_cython, __pyx_k_Event___setstate_cython, sizeof(__pyx_k_Event___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Event__getEventNames, __pyx_k_Event__getEventNames, sizeof(__pyx_k_Event__getEventNames), 0, 0, 1, 1}, + {&__pyx_n_s_Event_getName, __pyx_k_Event_getName, sizeof(__pyx_k_Event_getName), 0, 0, 1, 1}, + {&__pyx_n_s_Event_getNewBound, __pyx_k_Event_getNewBound, sizeof(__pyx_k_Event_getNewBound), 0, 0, 1, 1}, + {&__pyx_n_s_Event_getNode, __pyx_k_Event_getNode, sizeof(__pyx_k_Event_getNode), 0, 0, 1, 1}, + {&__pyx_n_s_Event_getOldBound, __pyx_k_Event_getOldBound, sizeof(__pyx_k_Event_getOldBound), 0, 0, 1, 1}, + {&__pyx_n_s_Event_getRow, __pyx_k_Event_getRow, sizeof(__pyx_k_Event_getRow), 0, 0, 1, 1}, + {&__pyx_n_s_Event_getType, __pyx_k_Event_getType, sizeof(__pyx_k_Event_getType), 0, 0, 1, 1}, + {&__pyx_n_s_Event_getVar, __pyx_k_Event_getVar, sizeof(__pyx_k_Event_getVar), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr, __pyx_k_Eventhdlr, sizeof(__pyx_k_Eventhdlr), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr___reduce_cython, __pyx_k_Eventhdlr___reduce_cython, sizeof(__pyx_k_Eventhdlr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr___setstate_cython, __pyx_k_Eventhdlr___setstate_cython, sizeof(__pyx_k_Eventhdlr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr_eventcopy, __pyx_k_Eventhdlr_eventcopy, sizeof(__pyx_k_Eventhdlr_eventcopy), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr_eventdelete, __pyx_k_Eventhdlr_eventdelete, sizeof(__pyx_k_Eventhdlr_eventdelete), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr_eventexec, __pyx_k_Eventhdlr_eventexec, sizeof(__pyx_k_Eventhdlr_eventexec), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr_eventexit, __pyx_k_Eventhdlr_eventexit, sizeof(__pyx_k_Eventhdlr_eventexit), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr_eventexitsol, __pyx_k_Eventhdlr_eventexitsol, sizeof(__pyx_k_Eventhdlr_eventexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr_eventfree, __pyx_k_Eventhdlr_eventfree, sizeof(__pyx_k_Eventhdlr_eventfree), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr_eventinit, __pyx_k_Eventhdlr_eventinit, sizeof(__pyx_k_Eventhdlr_eventinit), 0, 0, 1, 1}, + {&__pyx_n_s_Eventhdlr_eventinitsol, __pyx_k_Eventhdlr_eventinitsol, sizeof(__pyx_k_Eventhdlr_eventinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Expr, __pyx_k_Expr, sizeof(__pyx_k_Expr), 0, 0, 1, 1}, + {&__pyx_kp_u_ExprCons, __pyx_k_ExprCons, sizeof(__pyx_k_ExprCons), 0, 1, 0, 0}, + {&__pyx_n_s_ExprCons_2, __pyx_k_ExprCons_2, sizeof(__pyx_k_ExprCons_2), 0, 0, 1, 1}, + {&__pyx_n_s_ExprCons___reduce_cython, __pyx_k_ExprCons___reduce_cython, sizeof(__pyx_k_ExprCons___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ExprCons___setstate_cython, __pyx_k_ExprCons___setstate_cython, sizeof(__pyx_k_ExprCons___setstate_cython), 0, 0, 1, 1}, + {&__pyx_kp_u_ExprCons_already_has_lower_bound, __pyx_k_ExprCons_already_has_lower_bound, sizeof(__pyx_k_ExprCons_already_has_lower_bound), 0, 1, 0, 0}, + {&__pyx_kp_u_ExprCons_already_has_upper_bound, __pyx_k_ExprCons_already_has_upper_bound, sizeof(__pyx_k_ExprCons_already_has_upper_bound), 0, 1, 0, 0}, + {&__pyx_n_s_ExprCons_normalize, __pyx_k_ExprCons_normalize, sizeof(__pyx_k_ExprCons_normalize), 0, 0, 1, 1}, + {&__pyx_n_s_Expr___reduce_cython, __pyx_k_Expr___reduce_cython, sizeof(__pyx_k_Expr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Expr___setstate_cython, __pyx_k_Expr___setstate_cython, sizeof(__pyx_k_Expr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Expr_degree, __pyx_k_Expr_degree, sizeof(__pyx_k_Expr_degree), 0, 0, 1, 1}, + {&__pyx_n_s_Expr_normalize, __pyx_k_Expr_normalize, sizeof(__pyx_k_Expr_normalize), 0, 0, 1, 1}, + {&__pyx_kp_u_Expr_s, __pyx_k_Expr_s, sizeof(__pyx_k_Expr_s), 0, 1, 0, 0}, + {&__pyx_n_s_FAST, __pyx_k_FAST, sizeof(__pyx_k_FAST), 0, 0, 1, 1}, + {&__pyx_n_s_FEASIBILITY, __pyx_k_FEASIBILITY, sizeof(__pyx_k_FEASIBILITY), 0, 0, 1, 1}, + {&__pyx_n_s_FEASIBLE, __pyx_k_FEASIBLE, sizeof(__pyx_k_FEASIBLE), 0, 0, 1, 1}, + {&__pyx_n_s_FIRSTLPSOLVED, __pyx_k_FIRSTLPSOLVED, sizeof(__pyx_k_FIRSTLPSOLVED), 0, 0, 1, 1}, + {&__pyx_n_s_FIXED, __pyx_k_FIXED, sizeof(__pyx_k_FIXED), 0, 0, 1, 1}, + {&__pyx_n_s_FOCUSNODE, __pyx_k_FOCUSNODE, sizeof(__pyx_k_FOCUSNODE), 0, 0, 1, 1}, + {&__pyx_n_s_FORK, __pyx_k_FORK, sizeof(__pyx_k_FORK), 0, 0, 1, 1}, + {&__pyx_n_s_FOUNDSOL, __pyx_k_FOUNDSOL, sizeof(__pyx_k_FOUNDSOL), 0, 0, 1, 1}, + {&__pyx_n_s_FREE, __pyx_k_FREE, sizeof(__pyx_k_FREE), 0, 0, 1, 1}, + {&__pyx_n_s_FREETRANS, __pyx_k_FREETRANS, sizeof(__pyx_k_FREETRANS), 0, 0, 1, 1}, + {&__pyx_n_s_GAPLIMIT, __pyx_k_GAPLIMIT, sizeof(__pyx_k_GAPLIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_GBDCHANGED, __pyx_k_GBDCHANGED, sizeof(__pyx_k_GBDCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_GHOLEADDED, __pyx_k_GHOLEADDED, sizeof(__pyx_k_GHOLEADDED), 0, 0, 1, 1}, + {&__pyx_n_s_GHOLECHANGED, __pyx_k_GHOLECHANGED, sizeof(__pyx_k_GHOLECHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_GHOLEREMOVED, __pyx_k_GHOLEREMOVED, sizeof(__pyx_k_GHOLEREMOVED), 0, 0, 1, 1}, + {&__pyx_n_s_GLBCHANGED, __pyx_k_GLBCHANGED, sizeof(__pyx_k_GLBCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_GUBCHANGED, __pyx_k_GUBCHANGED, sizeof(__pyx_k_GUBCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_GenExpr, __pyx_k_GenExpr, sizeof(__pyx_k_GenExpr), 0, 0, 1, 1}, + {&__pyx_n_s_GenExpr___reduce_cython, __pyx_k_GenExpr___reduce_cython, sizeof(__pyx_k_GenExpr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_GenExpr___setstate_cython, __pyx_k_GenExpr___setstate_cython, sizeof(__pyx_k_GenExpr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_GenExpr_degree, __pyx_k_GenExpr_degree, sizeof(__pyx_k_GenExpr_degree), 0, 0, 1, 1}, + {&__pyx_n_s_GenExpr_getOp, __pyx_k_GenExpr_getOp, sizeof(__pyx_k_GenExpr_getOp), 0, 0, 1, 1}, + {&__pyx_kp_u_Given_constraint_list_is_not_ite, __pyx_k_Given_constraint_list_is_not_ite, sizeof(__pyx_k_Given_constraint_list_is_not_ite), 0, 1, 0, 0}, + {&__pyx_kp_u_Given_constraint_list_is_not_ite_2, __pyx_k_Given_constraint_list_is_not_ite_2, sizeof(__pyx_k_Given_constraint_list_is_not_ite_2), 0, 1, 0, 0}, + {&__pyx_n_s_HARDLP, __pyx_k_HARDLP, sizeof(__pyx_k_HARDLP), 0, 0, 1, 1}, + {&__pyx_n_s_HOLECHANGED, __pyx_k_HOLECHANGED, sizeof(__pyx_k_HOLECHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_Heur, __pyx_k_Heur, sizeof(__pyx_k_Heur), 0, 0, 1, 1}, + {&__pyx_n_s_Heur___reduce_cython, __pyx_k_Heur___reduce_cython, sizeof(__pyx_k_Heur___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Heur___setstate_cython, __pyx_k_Heur___setstate_cython, sizeof(__pyx_k_Heur___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Heur_heurexec, __pyx_k_Heur_heurexec, sizeof(__pyx_k_Heur_heurexec), 0, 0, 1, 1}, + {&__pyx_n_s_Heur_heurexit, __pyx_k_Heur_heurexit, sizeof(__pyx_k_Heur_heurexit), 0, 0, 1, 1}, + {&__pyx_n_s_Heur_heurexitsol, __pyx_k_Heur_heurexitsol, sizeof(__pyx_k_Heur_heurexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Heur_heurfree, __pyx_k_Heur_heurfree, sizeof(__pyx_k_Heur_heurfree), 0, 0, 1, 1}, + {&__pyx_n_s_Heur_heurinit, __pyx_k_Heur_heurinit, sizeof(__pyx_k_Heur_heurinit), 0, 0, 1, 1}, + {&__pyx_n_s_Heur_heurinitsol, __pyx_k_Heur_heurinitsol, sizeof(__pyx_k_Heur_heurinitsol), 0, 0, 1, 1}, + {&__pyx_n_u_I, __pyx_k_I, sizeof(__pyx_k_I), 0, 1, 0, 1}, + {&__pyx_n_s_IMPLADDED, __pyx_k_IMPLADDED, sizeof(__pyx_k_IMPLADDED), 0, 0, 1, 1}, + {&__pyx_n_u_IMPLINT, __pyx_k_IMPLINT, sizeof(__pyx_k_IMPLINT), 0, 1, 0, 1}, + {&__pyx_n_s_INFEASIBLE, __pyx_k_INFEASIBLE, sizeof(__pyx_k_INFEASIBLE), 0, 0, 1, 1}, + {&__pyx_n_s_INFORUNBD, __pyx_k_INFORUNBD, sizeof(__pyx_k_INFORUNBD), 0, 0, 1, 1}, + {&__pyx_n_s_INIT, __pyx_k_INIT, sizeof(__pyx_k_INIT), 0, 0, 1, 1}, + {&__pyx_n_s_INITPRESOLVE, __pyx_k_INITPRESOLVE, sizeof(__pyx_k_INITPRESOLVE), 0, 0, 1, 1}, + {&__pyx_n_s_INITSOLVE, __pyx_k_INITSOLVE, sizeof(__pyx_k_INITSOLVE), 0, 0, 1, 1}, + {&__pyx_n_u_INTEGER, __pyx_k_INTEGER, sizeof(__pyx_k_INTEGER), 0, 1, 0, 1}, + {&__pyx_n_s_IOError, __pyx_k_IOError, sizeof(__pyx_k_IOError), 0, 0, 1, 1}, + {&__pyx_n_s_ITERLIMIT, __pyx_k_ITERLIMIT, sizeof(__pyx_k_ITERLIMIT), 0, 0, 1, 1}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_10, __pyx_k_Incompatible_checksums_0x_x_vs_0_10, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_10), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_11, __pyx_k_Incompatible_checksums_0x_x_vs_0_11, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_11), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_12, __pyx_k_Incompatible_checksums_0x_x_vs_0_12, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_12), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_2, __pyx_k_Incompatible_checksums_0x_x_vs_0_2, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_2), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_3, __pyx_k_Incompatible_checksums_0x_x_vs_0_3, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_3), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_4, __pyx_k_Incompatible_checksums_0x_x_vs_0_4, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_4), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_5, __pyx_k_Incompatible_checksums_0x_x_vs_0_5, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_5), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_6, __pyx_k_Incompatible_checksums_0x_x_vs_0_6, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_6), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_7, __pyx_k_Incompatible_checksums_0x_x_vs_0_7, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_7), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_8, __pyx_k_Incompatible_checksums_0x_x_vs_0_8, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_8), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0_9, __pyx_k_Incompatible_checksums_0x_x_vs_0_9, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0_9), 0, 0, 1, 0}, + {&__pyx_n_u_IndicatorCons, __pyx_k_IndicatorCons, sizeof(__pyx_k_IndicatorCons), 0, 1, 0, 1}, + {&__pyx_n_s_Iterable, __pyx_k_Iterable, sizeof(__pyx_k_Iterable), 0, 0, 1, 1}, + {&__pyx_n_s_JUNCTION, __pyx_k_JUNCTION, sizeof(__pyx_k_JUNCTION), 0, 0, 1, 1}, + {&__pyx_n_s_KeyError, __pyx_k_KeyError, sizeof(__pyx_k_KeyError), 0, 0, 1, 1}, + {&__pyx_n_s_LBCHANGED, __pyx_k_LBCHANGED, sizeof(__pyx_k_LBCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_LBRELAXED, __pyx_k_LBRELAXED, sizeof(__pyx_k_LBRELAXED), 0, 0, 1, 1}, + {&__pyx_n_s_LBTIGHTENED, __pyx_k_LBTIGHTENED, sizeof(__pyx_k_LBTIGHTENED), 0, 0, 1, 1}, + {&__pyx_n_s_LC_NUMERIC, __pyx_k_LC_NUMERIC, sizeof(__pyx_k_LC_NUMERIC), 0, 0, 1, 1}, + {&__pyx_n_s_LEAF, __pyx_k_LEAF, sizeof(__pyx_k_LEAF), 0, 0, 1, 1}, + {&__pyx_n_s_LHOLEADDED, __pyx_k_LHOLEADDED, sizeof(__pyx_k_LHOLEADDED), 0, 0, 1, 1}, + {&__pyx_n_s_LHOLECHANGED, __pyx_k_LHOLECHANGED, sizeof(__pyx_k_LHOLECHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_LHOLEREMOVED, __pyx_k_LHOLEREMOVED, sizeof(__pyx_k_LHOLEREMOVED), 0, 0, 1, 1}, + {&__pyx_n_s_LP, __pyx_k_LP, sizeof(__pyx_k_LP), 0, 0, 1, 1}, + {&__pyx_n_u_LP, __pyx_k_LP, sizeof(__pyx_k_LP), 0, 1, 0, 1}, + {&__pyx_n_s_LPEVENT, __pyx_k_LPEVENT, sizeof(__pyx_k_LPEVENT), 0, 0, 1, 1}, + {&__pyx_n_s_LPSOLVED, __pyx_k_LPSOLVED, sizeof(__pyx_k_LPSOLVED), 0, 0, 1, 1}, + {&__pyx_n_s_LP___reduce_cython, __pyx_k_LP___reduce_cython, sizeof(__pyx_k_LP___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_LP___setstate_cython, __pyx_k_LP___setstate_cython, sizeof(__pyx_k_LP___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_LP_addCol, __pyx_k_LP_addCol, sizeof(__pyx_k_LP_addCol), 0, 0, 1, 1}, + {&__pyx_n_s_LP_addCols, __pyx_k_LP_addCols, sizeof(__pyx_k_LP_addCols), 0, 0, 1, 1}, + {&__pyx_n_s_LP_addRow, __pyx_k_LP_addRow, sizeof(__pyx_k_LP_addRow), 0, 0, 1, 1}, + {&__pyx_n_s_LP_addRows, __pyx_k_LP_addRows, sizeof(__pyx_k_LP_addRows), 0, 0, 1, 1}, + {&__pyx_n_s_LP_chgBound, __pyx_k_LP_chgBound, sizeof(__pyx_k_LP_chgBound), 0, 0, 1, 1}, + {&__pyx_n_s_LP_chgCoef, __pyx_k_LP_chgCoef, sizeof(__pyx_k_LP_chgCoef), 0, 0, 1, 1}, + {&__pyx_n_s_LP_chgObj, __pyx_k_LP_chgObj, sizeof(__pyx_k_LP_chgObj), 0, 0, 1, 1}, + {&__pyx_n_s_LP_chgSide, __pyx_k_LP_chgSide, sizeof(__pyx_k_LP_chgSide), 0, 0, 1, 1}, + {&__pyx_n_s_LP_clear, __pyx_k_LP_clear, sizeof(__pyx_k_LP_clear), 0, 0, 1, 1}, + {&__pyx_n_s_LP_delCols, __pyx_k_LP_delCols, sizeof(__pyx_k_LP_delCols), 0, 0, 1, 1}, + {&__pyx_n_s_LP_delRows, __pyx_k_LP_delRows, sizeof(__pyx_k_LP_delRows), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getBasisInds, __pyx_k_LP_getBasisInds, sizeof(__pyx_k_LP_getBasisInds), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getBounds, __pyx_k_LP_getBounds, sizeof(__pyx_k_LP_getBounds), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getDual, __pyx_k_LP_getDual, sizeof(__pyx_k_LP_getDual), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getDualRay, __pyx_k_LP_getDualRay, sizeof(__pyx_k_LP_getDualRay), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getNIterations, __pyx_k_LP_getNIterations, sizeof(__pyx_k_LP_getNIterations), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getPrimal, __pyx_k_LP_getPrimal, sizeof(__pyx_k_LP_getPrimal), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getPrimalRay, __pyx_k_LP_getPrimalRay, sizeof(__pyx_k_LP_getPrimalRay), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getRedcost, __pyx_k_LP_getRedcost, sizeof(__pyx_k_LP_getRedcost), 0, 0, 1, 1}, + {&__pyx_n_s_LP_getSides, __pyx_k_LP_getSides, sizeof(__pyx_k_LP_getSides), 0, 0, 1, 1}, + {&__pyx_n_s_LP_infinity, __pyx_k_LP_infinity, sizeof(__pyx_k_LP_infinity), 0, 0, 1, 1}, + {&__pyx_n_s_LP_isDualFeasible, __pyx_k_LP_isDualFeasible, sizeof(__pyx_k_LP_isDualFeasible), 0, 0, 1, 1}, + {&__pyx_n_s_LP_isInfinity, __pyx_k_LP_isInfinity, sizeof(__pyx_k_LP_isInfinity), 0, 0, 1, 1}, + {&__pyx_n_s_LP_isPrimalFeasible, __pyx_k_LP_isPrimalFeasible, sizeof(__pyx_k_LP_isPrimalFeasible), 0, 0, 1, 1}, + {&__pyx_kp_u_LP_lp, __pyx_k_LP_lp, sizeof(__pyx_k_LP_lp), 0, 1, 0, 0}, + {&__pyx_n_s_LP_ncols, __pyx_k_LP_ncols, sizeof(__pyx_k_LP_ncols), 0, 0, 1, 1}, + {&__pyx_n_s_LP_nrows, __pyx_k_LP_nrows, sizeof(__pyx_k_LP_nrows), 0, 0, 1, 1}, + {&__pyx_n_s_LP_readLP, __pyx_k_LP_readLP, sizeof(__pyx_k_LP_readLP), 0, 0, 1, 1}, + {&__pyx_n_s_LP_solve, __pyx_k_LP_solve, sizeof(__pyx_k_LP_solve), 0, 0, 1, 1}, + {&__pyx_n_s_LP_writeLP, __pyx_k_LP_writeLP, sizeof(__pyx_k_LP_writeLP), 0, 0, 1, 1}, + {&__pyx_n_s_LookupError, __pyx_k_LookupError, sizeof(__pyx_k_LookupError), 0, 0, 1, 1}, + {&__pyx_n_u_M, __pyx_k_M, sizeof(__pyx_k_M), 0, 1, 0, 1}, + {&__pyx_n_s_MAJOR, __pyx_k_MAJOR, sizeof(__pyx_k_MAJOR), 0, 0, 1, 1}, + {&__pyx_n_s_MEDIUM, __pyx_k_MEDIUM, sizeof(__pyx_k_MEDIUM), 0, 0, 1, 1}, + {&__pyx_n_s_MEMLIMIT, __pyx_k_MEMLIMIT, sizeof(__pyx_k_MEMLIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_MINOR, __pyx_k_MINOR, sizeof(__pyx_k_MINOR), 0, 0, 1, 1}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_n_s_Model, __pyx_k_Model, sizeof(__pyx_k_Model), 0, 0, 1, 1}, + {&__pyx_n_s_Model___reduce_cython, __pyx_k_Model___reduce_cython, sizeof(__pyx_k_Model___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Model___setstate_cython, __pyx_k_Model___setstate_cython, sizeof(__pyx_k_Model___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Model__createConsGenNonlinear, __pyx_k_Model__createConsGenNonlinear, sizeof(__pyx_k_Model__createConsGenNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model__createConsLinear, __pyx_k_Model__createConsLinear, sizeof(__pyx_k_Model__createConsLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model__createConsNonlinear, __pyx_k_Model__createConsNonlinear, sizeof(__pyx_k_Model__createConsNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model__createConsQuadratic, __pyx_k_Model__createConsQuadratic, sizeof(__pyx_k_Model__createConsQuadratic), 0, 0, 1, 1}, + {&__pyx_n_s_Model__getStageNames, __pyx_k_Model__getStageNames, sizeof(__pyx_k_Model__getStageNames), 0, 0, 1, 1}, + {&__pyx_n_s_Model_activateBenders, __pyx_k_Model_activateBenders, sizeof(__pyx_k_Model_activateBenders), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addBendersSubproblem, __pyx_k_Model_addBendersSubproblem, sizeof(__pyx_k_Model_addBendersSubproblem), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addCoefLinear, __pyx_k_Model_addCoefLinear, sizeof(__pyx_k_Model_addCoefLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addCons, __pyx_k_Model_addCons, sizeof(__pyx_k_Model_addCons), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsAnd, __pyx_k_Model_addConsAnd, sizeof(__pyx_k_Model_addConsAnd), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsCardinality, __pyx_k_Model_addConsCardinality, sizeof(__pyx_k_Model_addConsCardinality), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsCoeff, __pyx_k_Model_addConsCoeff, sizeof(__pyx_k_Model_addConsCoeff), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsDisjunction, __pyx_k_Model_addConsDisjunction, sizeof(__pyx_k_Model_addConsDisjunction), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsElemDisjunction, __pyx_k_Model_addConsElemDisjunction, sizeof(__pyx_k_Model_addConsElemDisjunction), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsIndicator, __pyx_k_Model_addConsIndicator, sizeof(__pyx_k_Model_addConsIndicator), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsLocal, __pyx_k_Model_addConsLocal, sizeof(__pyx_k_Model_addConsLocal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsNode, __pyx_k_Model_addConsNode, sizeof(__pyx_k_Model_addConsNode), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsOr, __pyx_k_Model_addConsOr, sizeof(__pyx_k_Model_addConsOr), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsSOS1, __pyx_k_Model_addConsSOS1, sizeof(__pyx_k_Model_addConsSOS1), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsSOS2, __pyx_k_Model_addConsSOS2, sizeof(__pyx_k_Model_addConsSOS2), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConsXor, __pyx_k_Model_addConsXor, sizeof(__pyx_k_Model_addConsXor), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addConss, __pyx_k_Model_addConss, sizeof(__pyx_k_Model_addConss), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addCut, __pyx_k_Model_addCut, sizeof(__pyx_k_Model_addCut), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addExprNonlinear, __pyx_k_Model_addExprNonlinear, sizeof(__pyx_k_Model_addExprNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addObjoffset, __pyx_k_Model_addObjoffset, sizeof(__pyx_k_Model_addObjoffset), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addPoolCut, __pyx_k_Model_addPoolCut, sizeof(__pyx_k_Model_addPoolCut), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addPyCons, __pyx_k_Model_addPyCons, sizeof(__pyx_k_Model_addPyCons), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addRowDive, __pyx_k_Model_addRowDive, sizeof(__pyx_k_Model_addRowDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addSol, __pyx_k_Model_addSol, sizeof(__pyx_k_Model_addSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addVar, __pyx_k_Model_addVar, sizeof(__pyx_k_Model_addVar), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addVarLocks, __pyx_k_Model_addVarLocks, sizeof(__pyx_k_Model_addVarLocks), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addVarSOS1, __pyx_k_Model_addVarSOS1, sizeof(__pyx_k_Model_addVarSOS1), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addVarSOS2, __pyx_k_Model_addVarSOS2, sizeof(__pyx_k_Model_addVarSOS2), 0, 0, 1, 1}, + {&__pyx_n_s_Model_addVarToRow, __pyx_k_Model_addVarToRow, sizeof(__pyx_k_Model_addVarToRow), 0, 0, 1, 1}, + {&__pyx_n_s_Model_appendVarSOS1, __pyx_k_Model_appendVarSOS1, sizeof(__pyx_k_Model_appendVarSOS1), 0, 0, 1, 1}, + {&__pyx_n_s_Model_appendVarSOS2, __pyx_k_Model_appendVarSOS2, sizeof(__pyx_k_Model_appendVarSOS2), 0, 0, 1, 1}, + {&__pyx_n_s_Model_applyCutsProbing, __pyx_k_Model_applyCutsProbing, sizeof(__pyx_k_Model_applyCutsProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_backtrackProbing, __pyx_k_Model_backtrackProbing, sizeof(__pyx_k_Model_backtrackProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_branchVar, __pyx_k_Model_branchVar, sizeof(__pyx_k_Model_branchVar), 0, 0, 1, 1}, + {&__pyx_n_s_Model_branchVarVal, __pyx_k_Model_branchVarVal, sizeof(__pyx_k_Model_branchVarVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_cacheRowExtensions, __pyx_k_Model_cacheRowExtensions, sizeof(__pyx_k_Model_cacheRowExtensions), 0, 0, 1, 1}, + {&__pyx_n_s_Model_calcChildEstimate, __pyx_k_Model_calcChildEstimate, sizeof(__pyx_k_Model_calcChildEstimate), 0, 0, 1, 1}, + {&__pyx_n_s_Model_calcNodeselPriority, __pyx_k_Model_calcNodeselPriority, sizeof(__pyx_k_Model_calcNodeselPriority), 0, 0, 1, 1}, + {&__pyx_n_s_Model_catchEvent, __pyx_k_Model_catchEvent, sizeof(__pyx_k_Model_catchEvent), 0, 0, 1, 1}, + {&__pyx_n_s_Model_catchRowEvent, __pyx_k_Model_catchRowEvent, sizeof(__pyx_k_Model_catchRowEvent), 0, 0, 1, 1}, + {&__pyx_n_s_Model_catchVarEvent, __pyx_k_Model_catchVarEvent, sizeof(__pyx_k_Model_catchVarEvent), 0, 0, 1, 1}, + {&__pyx_n_s_Model_checkBendersSubproblemOpti, __pyx_k_Model_checkBendersSubproblemOpti, sizeof(__pyx_k_Model_checkBendersSubproblemOpti), 0, 0, 1, 1}, + {&__pyx_n_s_Model_checkQuadraticNonlinear, __pyx_k_Model_checkQuadraticNonlinear, sizeof(__pyx_k_Model_checkQuadraticNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_checkSol, __pyx_k_Model_checkSol, sizeof(__pyx_k_Model_checkSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgCoefLinear, __pyx_k_Model_chgCoefLinear, sizeof(__pyx_k_Model_chgCoefLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgLhs, __pyx_k_Model_chgLhs, sizeof(__pyx_k_Model_chgLhs), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgReoptObjective, __pyx_k_Model_chgReoptObjective, sizeof(__pyx_k_Model_chgReoptObjective), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgRhs, __pyx_k_Model_chgRhs, sizeof(__pyx_k_Model_chgRhs), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgRowLhsDive, __pyx_k_Model_chgRowLhsDive, sizeof(__pyx_k_Model_chgRowLhsDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgRowRhsDive, __pyx_k_Model_chgRowRhsDive, sizeof(__pyx_k_Model_chgRowRhsDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarBranchPriority, __pyx_k_Model_chgVarBranchPriority, sizeof(__pyx_k_Model_chgVarBranchPriority), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarLb, __pyx_k_Model_chgVarLb, sizeof(__pyx_k_Model_chgVarLb), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarLbDive, __pyx_k_Model_chgVarLbDive, sizeof(__pyx_k_Model_chgVarLbDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarLbGlobal, __pyx_k_Model_chgVarLbGlobal, sizeof(__pyx_k_Model_chgVarLbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarLbNode, __pyx_k_Model_chgVarLbNode, sizeof(__pyx_k_Model_chgVarLbNode), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarLbProbing, __pyx_k_Model_chgVarLbProbing, sizeof(__pyx_k_Model_chgVarLbProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarObjDive, __pyx_k_Model_chgVarObjDive, sizeof(__pyx_k_Model_chgVarObjDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarObjProbing, __pyx_k_Model_chgVarObjProbing, sizeof(__pyx_k_Model_chgVarObjProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarType, __pyx_k_Model_chgVarType, sizeof(__pyx_k_Model_chgVarType), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarUb, __pyx_k_Model_chgVarUb, sizeof(__pyx_k_Model_chgVarUb), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarUbDive, __pyx_k_Model_chgVarUbDive, sizeof(__pyx_k_Model_chgVarUbDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarUbGlobal, __pyx_k_Model_chgVarUbGlobal, sizeof(__pyx_k_Model_chgVarUbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarUbNode, __pyx_k_Model_chgVarUbNode, sizeof(__pyx_k_Model_chgVarUbNode), 0, 0, 1, 1}, + {&__pyx_n_s_Model_chgVarUbProbing, __pyx_k_Model_chgVarUbProbing, sizeof(__pyx_k_Model_chgVarUbProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_computeBestSolSubproblems, __pyx_k_Model_computeBestSolSubproblems, sizeof(__pyx_k_Model_computeBestSolSubproblems), 0, 0, 1, 1}, + {&__pyx_n_s_Model_constructLP, __pyx_k_Model_constructLP, sizeof(__pyx_k_Model_constructLP), 0, 0, 1, 1}, + {&__pyx_n_s_Model_count, __pyx_k_Model_count, sizeof(__pyx_k_Model_count), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createChild, __pyx_k_Model_createChild, sizeof(__pyx_k_Model_createChild), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createCons, __pyx_k_Model_createCons, sizeof(__pyx_k_Model_createCons), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createConsFromExpr, __pyx_k_Model_createConsFromExpr, sizeof(__pyx_k_Model_createConsFromExpr), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createEmptyRowSepa, __pyx_k_Model_createEmptyRowSepa, sizeof(__pyx_k_Model_createEmptyRowSepa), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createEmptyRowUnspec, __pyx_k_Model_createEmptyRowUnspec, sizeof(__pyx_k_Model_createEmptyRowUnspec), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createOrigSol, __pyx_k_Model_createOrigSol, sizeof(__pyx_k_Model_createOrigSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createPartialSol, __pyx_k_Model_createPartialSol, sizeof(__pyx_k_Model_createPartialSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createProbBasic, __pyx_k_Model_createProbBasic, sizeof(__pyx_k_Model_createProbBasic), 0, 0, 1, 1}, + {&__pyx_n_s_Model_createSol, __pyx_k_Model_createSol, sizeof(__pyx_k_Model_createSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_delCoefLinear, __pyx_k_Model_delCoefLinear, sizeof(__pyx_k_Model_delCoefLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_delCons, __pyx_k_Model_delCons, sizeof(__pyx_k_Model_delCons), 0, 0, 1, 1}, + {&__pyx_n_s_Model_delConsLocal, __pyx_k_Model_delConsLocal, sizeof(__pyx_k_Model_delConsLocal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_delVar, __pyx_k_Model_delVar, sizeof(__pyx_k_Model_delVar), 0, 0, 1, 1}, + {&__pyx_n_s_Model_disablePropagation, __pyx_k_Model_disablePropagation, sizeof(__pyx_k_Model_disablePropagation), 0, 0, 1, 1}, + {&__pyx_n_s_Model_dropEvent, __pyx_k_Model_dropEvent, sizeof(__pyx_k_Model_dropEvent), 0, 0, 1, 1}, + {&__pyx_n_s_Model_dropRowEvent, __pyx_k_Model_dropRowEvent, sizeof(__pyx_k_Model_dropRowEvent), 0, 0, 1, 1}, + {&__pyx_n_s_Model_dropVarEvent, __pyx_k_Model_dropVarEvent, sizeof(__pyx_k_Model_dropVarEvent), 0, 0, 1, 1}, + {&__pyx_n_s_Model_enableReoptimization, __pyx_k_Model_enableReoptimization, sizeof(__pyx_k_Model_enableReoptimization), 0, 0, 1, 1}, + {&__pyx_n_s_Model_endDive, __pyx_k_Model_endDive, sizeof(__pyx_k_Model_endDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_endProbing, __pyx_k_Model_endProbing, sizeof(__pyx_k_Model_endProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_epsilon, __pyx_k_Model_epsilon, sizeof(__pyx_k_Model_epsilon), 0, 0, 1, 1}, + {&__pyx_n_s_Model_feasFrac, __pyx_k_Model_feasFrac, sizeof(__pyx_k_Model_feasFrac), 0, 0, 1, 1}, + {&__pyx_n_s_Model_feastol, __pyx_k_Model_feastol, sizeof(__pyx_k_Model_feastol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_fixVar, __pyx_k_Model_fixVar, sizeof(__pyx_k_Model_fixVar), 0, 0, 1, 1}, + {&__pyx_n_s_Model_fixVarProbing, __pyx_k_Model_fixVarProbing, sizeof(__pyx_k_Model_fixVarProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_flushRowExtensions, __pyx_k_Model_flushRowExtensions, sizeof(__pyx_k_Model_flushRowExtensions), 0, 0, 1, 1}, + {&__pyx_n_s_Model_frac, __pyx_k_Model_frac, sizeof(__pyx_k_Model_frac), 0, 0, 1, 1}, + {&__pyx_n_s_Model_freeBendersSubproblems, __pyx_k_Model_freeBendersSubproblems, sizeof(__pyx_k_Model_freeBendersSubproblems), 0, 0, 1, 1}, + {&__pyx_n_s_Model_freeProb, __pyx_k_Model_freeProb, sizeof(__pyx_k_Model_freeProb), 0, 0, 1, 1}, + {&__pyx_n_s_Model_freeReoptSolve, __pyx_k_Model_freeReoptSolve, sizeof(__pyx_k_Model_freeReoptSolve), 0, 0, 1, 1}, + {&__pyx_n_s_Model_freeSol, __pyx_k_Model_freeSol, sizeof(__pyx_k_Model_freeSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_freeTransform, __pyx_k_Model_freeTransform, sizeof(__pyx_k_Model_freeTransform), 0, 0, 1, 1}, + {&__pyx_n_s_Model_from_ptr, __pyx_k_Model_from_ptr, sizeof(__pyx_k_Model_from_ptr), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getActivity, __pyx_k_Model_getActivity, sizeof(__pyx_k_Model_getActivity), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBendersAuxiliaryVar, __pyx_k_Model_getBendersAuxiliaryVar, sizeof(__pyx_k_Model_getBendersAuxiliaryVar), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBendersSubproblem, __pyx_k_Model_getBendersSubproblem, sizeof(__pyx_k_Model_getBendersSubproblem), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBendersVar, __pyx_k_Model_getBendersVar, sizeof(__pyx_k_Model_getBendersVar), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBestChild, __pyx_k_Model_getBestChild, sizeof(__pyx_k_Model_getBestChild), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBestLeaf, __pyx_k_Model_getBestLeaf, sizeof(__pyx_k_Model_getBestLeaf), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBestNode, __pyx_k_Model_getBestNode, sizeof(__pyx_k_Model_getBestNode), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBestSibling, __pyx_k_Model_getBestSibling, sizeof(__pyx_k_Model_getBestSibling), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBestSol, __pyx_k_Model_getBestSol, sizeof(__pyx_k_Model_getBestSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getBestboundNode, __pyx_k_Model_getBestboundNode, sizeof(__pyx_k_Model_getBestboundNode), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getCondition, __pyx_k_Model_getCondition, sizeof(__pyx_k_Model_getCondition), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getConsNVars, __pyx_k_Model_getConsNVars, sizeof(__pyx_k_Model_getConsNVars), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getConsVars, __pyx_k_Model_getConsVars, sizeof(__pyx_k_Model_getConsVars), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getConss, __pyx_k_Model_getConss, sizeof(__pyx_k_Model_getConss), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getCurrentNode, __pyx_k_Model_getCurrentNode, sizeof(__pyx_k_Model_getCurrentNode), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getCutEfficacy, __pyx_k_Model_getCutEfficacy, sizeof(__pyx_k_Model_getCutEfficacy), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getCutLPSolCutoffDistance, __pyx_k_Model_getCutLPSolCutoffDistance, sizeof(__pyx_k_Model_getCutLPSolCutoffDistance), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getDepth, __pyx_k_Model_getDepth, sizeof(__pyx_k_Model_getDepth), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getDualMultiplier, __pyx_k_Model_getDualMultiplier, sizeof(__pyx_k_Model_getDualMultiplier), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getDualSolVal, __pyx_k_Model_getDualSolVal, sizeof(__pyx_k_Model_getDualSolVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getDualbound, __pyx_k_Model_getDualbound, sizeof(__pyx_k_Model_getDualbound), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getDualboundRoot, __pyx_k_Model_getDualboundRoot, sizeof(__pyx_k_Model_getDualboundRoot), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getDualfarkasLinear, __pyx_k_Model_getDualfarkasLinear, sizeof(__pyx_k_Model_getDualfarkasLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getDualsolLinear, __pyx_k_Model_getDualsolLinear, sizeof(__pyx_k_Model_getDualsolLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getGap, __pyx_k_Model_getGap, sizeof(__pyx_k_Model_getGap), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLPBInvARow, __pyx_k_Model_getLPBInvARow, sizeof(__pyx_k_Model_getLPBInvARow), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLPBInvRow, __pyx_k_Model_getLPBInvRow, sizeof(__pyx_k_Model_getLPBInvRow), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLPBasisInd, __pyx_k_Model_getLPBasisInd, sizeof(__pyx_k_Model_getLPBasisInd), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLPBranchCands, __pyx_k_Model_getLPBranchCands, sizeof(__pyx_k_Model_getLPBranchCands), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLPColsData, __pyx_k_Model_getLPColsData, sizeof(__pyx_k_Model_getLPColsData), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLPObjVal, __pyx_k_Model_getLPObjVal, sizeof(__pyx_k_Model_getLPObjVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLPRowsData, __pyx_k_Model_getLPRowsData, sizeof(__pyx_k_Model_getLPRowsData), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLPSolstat, __pyx_k_Model_getLPSolstat, sizeof(__pyx_k_Model_getLPSolstat), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLhs, __pyx_k_Model_getLhs, sizeof(__pyx_k_Model_getLhs), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getLocalEstimate, __pyx_k_Model_getLocalEstimate, sizeof(__pyx_k_Model_getLocalEstimate), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNBestSolsFound, __pyx_k_Model_getNBestSolsFound, sizeof(__pyx_k_Model_getNBestSolsFound), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNBinVars, __pyx_k_Model_getNBinVars, sizeof(__pyx_k_Model_getNBinVars), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNChildren, __pyx_k_Model_getNChildren, sizeof(__pyx_k_Model_getNChildren), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNConss, __pyx_k_Model_getNConss, sizeof(__pyx_k_Model_getNConss), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNCountedSols, __pyx_k_Model_getNCountedSols, sizeof(__pyx_k_Model_getNCountedSols), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNCuts, __pyx_k_Model_getNCuts, sizeof(__pyx_k_Model_getNCuts), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNCutsApplied, __pyx_k_Model_getNCutsApplied, sizeof(__pyx_k_Model_getNCutsApplied), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNFeasibleLeaves, __pyx_k_Model_getNFeasibleLeaves, sizeof(__pyx_k_Model_getNFeasibleLeaves), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNInfeasibleLeaves, __pyx_k_Model_getNInfeasibleLeaves, sizeof(__pyx_k_Model_getNInfeasibleLeaves), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNIntVars, __pyx_k_Model_getNIntVars, sizeof(__pyx_k_Model_getNIntVars), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNLPCols, __pyx_k_Model_getNLPCols, sizeof(__pyx_k_Model_getNLPCols), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNLPIterations, __pyx_k_Model_getNLPIterations, sizeof(__pyx_k_Model_getNLPIterations), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNLPRows, __pyx_k_Model_getNLPRows, sizeof(__pyx_k_Model_getNLPRows), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNLPs, __pyx_k_Model_getNLPs, sizeof(__pyx_k_Model_getNLPs), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNLeaves, __pyx_k_Model_getNLeaves, sizeof(__pyx_k_Model_getNLeaves), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNLimSolsFound, __pyx_k_Model_getNLimSolsFound, sizeof(__pyx_k_Model_getNLimSolsFound), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNNlRows, __pyx_k_Model_getNNlRows, sizeof(__pyx_k_Model_getNNlRows), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNNodes, __pyx_k_Model_getNNodes, sizeof(__pyx_k_Model_getNNodes), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNReaders, __pyx_k_Model_getNReaders, sizeof(__pyx_k_Model_getNReaders), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNSepaRounds, __pyx_k_Model_getNSepaRounds, sizeof(__pyx_k_Model_getNSepaRounds), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNSiblings, __pyx_k_Model_getNSiblings, sizeof(__pyx_k_Model_getNSiblings), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNSols, __pyx_k_Model_getNSols, sizeof(__pyx_k_Model_getNSols), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNSolsFound, __pyx_k_Model_getNSolsFound, sizeof(__pyx_k_Model_getNSolsFound), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNTotalNodes, __pyx_k_Model_getNTotalNodes, sizeof(__pyx_k_Model_getNTotalNodes), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNVars, __pyx_k_Model_getNVars, sizeof(__pyx_k_Model_getNVars), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNlRowActivityBounds, __pyx_k_Model_getNlRowActivityBounds, sizeof(__pyx_k_Model_getNlRowActivityBounds), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNlRowSolActivity, __pyx_k_Model_getNlRowSolActivity, sizeof(__pyx_k_Model_getNlRowSolActivity), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNlRowSolFeasibility, __pyx_k_Model_getNlRowSolFeasibility, sizeof(__pyx_k_Model_getNlRowSolFeasibility), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getNlRows, __pyx_k_Model_getNlRows, sizeof(__pyx_k_Model_getNlRows), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getObjVal, __pyx_k_Model_getObjVal, sizeof(__pyx_k_Model_getObjVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getObjective, __pyx_k_Model_getObjective, sizeof(__pyx_k_Model_getObjective), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getObjectiveSense, __pyx_k_Model_getObjectiveSense, sizeof(__pyx_k_Model_getObjectiveSense), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getObjlimit, __pyx_k_Model_getObjlimit, sizeof(__pyx_k_Model_getObjlimit), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getObjoffset, __pyx_k_Model_getObjoffset, sizeof(__pyx_k_Model_getObjoffset), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getOpenNodes, __pyx_k_Model_getOpenNodes, sizeof(__pyx_k_Model_getOpenNodes), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getParam, __pyx_k_Model_getParam, sizeof(__pyx_k_Model_getParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getParams, __pyx_k_Model_getParams, sizeof(__pyx_k_Model_getParams), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getPresolvingTime, __pyx_k_Model_getPresolvingTime, sizeof(__pyx_k_Model_getPresolvingTime), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getPrimalRay, __pyx_k_Model_getPrimalRay, sizeof(__pyx_k_Model_getPrimalRay), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getPrimalRayVal, __pyx_k_Model_getPrimalRayVal, sizeof(__pyx_k_Model_getPrimalRayVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getPrimalbound, __pyx_k_Model_getPrimalbound, sizeof(__pyx_k_Model_getPrimalbound), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getProbName, __pyx_k_Model_getProbName, sizeof(__pyx_k_Model_getProbName), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getProbingDepth, __pyx_k_Model_getProbingDepth, sizeof(__pyx_k_Model_getProbingDepth), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getPseudoBranchCands, __pyx_k_Model_getPseudoBranchCands, sizeof(__pyx_k_Model_getPseudoBranchCands), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getReadingTime, __pyx_k_Model_getReadingTime, sizeof(__pyx_k_Model_getReadingTime), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getRhs, __pyx_k_Model_getRhs, sizeof(__pyx_k_Model_getRhs), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getRowActivity, __pyx_k_Model_getRowActivity, sizeof(__pyx_k_Model_getRowActivity), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getRowDualSol, __pyx_k_Model_getRowDualSol, sizeof(__pyx_k_Model_getRowDualSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getRowLPActivity, __pyx_k_Model_getRowLPActivity, sizeof(__pyx_k_Model_getRowLPActivity), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getRowLinear, __pyx_k_Model_getRowLinear, sizeof(__pyx_k_Model_getRowLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getRowNumIntCols, __pyx_k_Model_getRowNumIntCols, sizeof(__pyx_k_Model_getRowNumIntCols), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getRowObjParallelism, __pyx_k_Model_getRowObjParallelism, sizeof(__pyx_k_Model_getRowObjParallelism), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getRowParallelism, __pyx_k_Model_getRowParallelism, sizeof(__pyx_k_Model_getRowParallelism), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getSlack, __pyx_k_Model_getSlack, sizeof(__pyx_k_Model_getSlack), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getSlackVarIndicator, __pyx_k_Model_getSlackVarIndicator, sizeof(__pyx_k_Model_getSlackVarIndicator), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getSolObjVal, __pyx_k_Model_getSolObjVal, sizeof(__pyx_k_Model_getSolObjVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getSolTime, __pyx_k_Model_getSolTime, sizeof(__pyx_k_Model_getSolTime), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getSolVal, __pyx_k_Model_getSolVal, sizeof(__pyx_k_Model_getSolVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getSols, __pyx_k_Model_getSols, sizeof(__pyx_k_Model_getSols), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getSolvingTime, __pyx_k_Model_getSolvingTime, sizeof(__pyx_k_Model_getSolvingTime), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getStage, __pyx_k_Model_getStage, sizeof(__pyx_k_Model_getStage), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getStageName, __pyx_k_Model_getStageName, sizeof(__pyx_k_Model_getStageName), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getStatus, __pyx_k_Model_getStatus, sizeof(__pyx_k_Model_getStatus), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getTermsQuadratic, __pyx_k_Model_getTermsQuadratic, sizeof(__pyx_k_Model_getTermsQuadratic), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getTotalTime, __pyx_k_Model_getTotalTime, sizeof(__pyx_k_Model_getTotalTime), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getTransformedCons, __pyx_k_Model_getTransformedCons, sizeof(__pyx_k_Model_getTransformedCons), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getTransformedVar, __pyx_k_Model_getTransformedVar, sizeof(__pyx_k_Model_getTransformedVar), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getTreesizeEstimation, __pyx_k_Model_getTreesizeEstimation, sizeof(__pyx_k_Model_getTreesizeEstimation), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getVal, __pyx_k_Model_getVal, sizeof(__pyx_k_Model_getVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getValsLinear, __pyx_k_Model_getValsLinear, sizeof(__pyx_k_Model_getValsLinear), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getVarDict, __pyx_k_Model_getVarDict, sizeof(__pyx_k_Model_getVarDict), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getVarLbDive, __pyx_k_Model_getVarLbDive, sizeof(__pyx_k_Model_getVarLbDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getVarRedcost, __pyx_k_Model_getVarRedcost, sizeof(__pyx_k_Model_getVarRedcost), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getVarUbDive, __pyx_k_Model_getVarUbDive, sizeof(__pyx_k_Model_getVarUbDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_getVars, __pyx_k_Model_getVars, sizeof(__pyx_k_Model_getVars), 0, 0, 1, 1}, + {&__pyx_n_s_Model_hasPrimalRay, __pyx_k_Model_hasPrimalRay, sizeof(__pyx_k_Model_hasPrimalRay), 0, 0, 1, 1}, + {&__pyx_n_s_Model_hideOutput, __pyx_k_Model_hideOutput, sizeof(__pyx_k_Model_hideOutput), 0, 0, 1, 1}, + {&__pyx_n_s_Model_inProbing, __pyx_k_Model_inProbing, sizeof(__pyx_k_Model_inProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_inRepropagation, __pyx_k_Model_inRepropagation, sizeof(__pyx_k_Model_inRepropagation), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeBenders, __pyx_k_Model_includeBenders, sizeof(__pyx_k_Model_includeBenders), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeBendersDefaultCuts, __pyx_k_Model_includeBendersDefaultCuts, sizeof(__pyx_k_Model_includeBendersDefaultCuts), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeBenderscut, __pyx_k_Model_includeBenderscut, sizeof(__pyx_k_Model_includeBenderscut), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeBranchrule, __pyx_k_Model_includeBranchrule, sizeof(__pyx_k_Model_includeBranchrule), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeConshdlr, __pyx_k_Model_includeConshdlr, sizeof(__pyx_k_Model_includeConshdlr), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeCutsel, __pyx_k_Model_includeCutsel, sizeof(__pyx_k_Model_includeCutsel), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeDefaultPlugins, __pyx_k_Model_includeDefaultPlugins, sizeof(__pyx_k_Model_includeDefaultPlugins), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeEventhdlr, __pyx_k_Model_includeEventhdlr, sizeof(__pyx_k_Model_includeEventhdlr), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeHeur, __pyx_k_Model_includeHeur, sizeof(__pyx_k_Model_includeHeur), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeNodesel, __pyx_k_Model_includeNodesel, sizeof(__pyx_k_Model_includeNodesel), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includePresol, __pyx_k_Model_includePresol, sizeof(__pyx_k_Model_includePresol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includePricer, __pyx_k_Model_includePricer, sizeof(__pyx_k_Model_includePricer), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeProp, __pyx_k_Model_includeProp, sizeof(__pyx_k_Model_includeProp), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeReader, __pyx_k_Model_includeReader, sizeof(__pyx_k_Model_includeReader), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeRelax, __pyx_k_Model_includeRelax, sizeof(__pyx_k_Model_includeRelax), 0, 0, 1, 1}, + {&__pyx_n_s_Model_includeSepa, __pyx_k_Model_includeSepa, sizeof(__pyx_k_Model_includeSepa), 0, 0, 1, 1}, + {&__pyx_n_s_Model_infinity, __pyx_k_Model_infinity, sizeof(__pyx_k_Model_infinity), 0, 0, 1, 1}, + {&__pyx_n_s_Model_initBendersDefault, __pyx_k_Model_initBendersDefault, sizeof(__pyx_k_Model_initBendersDefault), 0, 0, 1, 1}, + {&__pyx_n_s_Model_interruptSolve, __pyx_k_Model_interruptSolve, sizeof(__pyx_k_Model_interruptSolve), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isCutEfficacious, __pyx_k_Model_isCutEfficacious, sizeof(__pyx_k_Model_isCutEfficacious), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isEQ, __pyx_k_Model_isEQ, sizeof(__pyx_k_Model_isEQ), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isFeasEQ, __pyx_k_Model_isFeasEQ, sizeof(__pyx_k_Model_isFeasEQ), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isFeasIntegral, __pyx_k_Model_isFeasIntegral, sizeof(__pyx_k_Model_isFeasIntegral), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isFeasNegative, __pyx_k_Model_isFeasNegative, sizeof(__pyx_k_Model_isFeasNegative), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isFeasZero, __pyx_k_Model_isFeasZero, sizeof(__pyx_k_Model_isFeasZero), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isGE, __pyx_k_Model_isGE, sizeof(__pyx_k_Model_isGE), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isGT, __pyx_k_Model_isGT, sizeof(__pyx_k_Model_isGT), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isInfinity, __pyx_k_Model_isInfinity, sizeof(__pyx_k_Model_isInfinity), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isLE, __pyx_k_Model_isLE, sizeof(__pyx_k_Model_isLE), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isLPSolBasic, __pyx_k_Model_isLPSolBasic, sizeof(__pyx_k_Model_isLPSolBasic), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isLT, __pyx_k_Model_isLT, sizeof(__pyx_k_Model_isLT), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isNLPConstructed, __pyx_k_Model_isNLPConstructed, sizeof(__pyx_k_Model_isNLPConstructed), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isObjChangedProbing, __pyx_k_Model_isObjChangedProbing, sizeof(__pyx_k_Model_isObjChangedProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_isZero, __pyx_k_Model_isZero, sizeof(__pyx_k_Model_isZero), 0, 0, 1, 1}, + {&__pyx_n_s_Model_lpiGetIterations, __pyx_k_Model_lpiGetIterations, sizeof(__pyx_k_Model_lpiGetIterations), 0, 0, 1, 1}, + {&__pyx_n_s_Model_newProbingNode, __pyx_k_Model_newProbingNode, sizeof(__pyx_k_Model_newProbingNode), 0, 0, 1, 1}, + {&__pyx_n_s_Model_optimize, __pyx_k_Model_optimize, sizeof(__pyx_k_Model_optimize), 0, 0, 1, 1}, + {&__pyx_n_s_Model_presolve, __pyx_k_Model_presolve, sizeof(__pyx_k_Model_presolve), 0, 0, 1, 1}, + {&__pyx_n_s_Model_printBestSol, __pyx_k_Model_printBestSol, sizeof(__pyx_k_Model_printBestSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_printCons, __pyx_k_Model_printCons, sizeof(__pyx_k_Model_printCons), 0, 0, 1, 1}, + {&__pyx_n_s_Model_printExternalCodeVersions, __pyx_k_Model_printExternalCodeVersions, sizeof(__pyx_k_Model_printExternalCodeVersions), 0, 0, 1, 1}, + {&__pyx_n_s_Model_printNlRow, __pyx_k_Model_printNlRow, sizeof(__pyx_k_Model_printNlRow), 0, 0, 1, 1}, + {&__pyx_n_s_Model_printRow, __pyx_k_Model_printRow, sizeof(__pyx_k_Model_printRow), 0, 0, 1, 1}, + {&__pyx_n_s_Model_printSol, __pyx_k_Model_printSol, sizeof(__pyx_k_Model_printSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_printStatistics, __pyx_k_Model_printStatistics, sizeof(__pyx_k_Model_printStatistics), 0, 0, 1, 1}, + {&__pyx_n_s_Model_printVersion, __pyx_k_Model_printVersion, sizeof(__pyx_k_Model_printVersion), 0, 0, 1, 1}, + {&__pyx_n_s_Model_propagateProbing, __pyx_k_Model_propagateProbing, sizeof(__pyx_k_Model_propagateProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_readParams, __pyx_k_Model_readParams, sizeof(__pyx_k_Model_readParams), 0, 0, 1, 1}, + {&__pyx_n_s_Model_readProblem, __pyx_k_Model_readProblem, sizeof(__pyx_k_Model_readProblem), 0, 0, 1, 1}, + {&__pyx_n_s_Model_readSol, __pyx_k_Model_readSol, sizeof(__pyx_k_Model_readSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_readSolFile, __pyx_k_Model_readSolFile, sizeof(__pyx_k_Model_readSolFile), 0, 0, 1, 1}, + {&__pyx_n_s_Model_redirectOutput, __pyx_k_Model_redirectOutput, sizeof(__pyx_k_Model_redirectOutput), 0, 0, 1, 1}, + {&__pyx_n_s_Model_relax, __pyx_k_Model_relax, sizeof(__pyx_k_Model_relax), 0, 0, 1, 1}, + {&__pyx_n_s_Model_releaseRow, __pyx_k_Model_releaseRow, sizeof(__pyx_k_Model_releaseRow), 0, 0, 1, 1}, + {&__pyx_n_s_Model_repropagateNode, __pyx_k_Model_repropagateNode, sizeof(__pyx_k_Model_repropagateNode), 0, 0, 1, 1}, + {&__pyx_n_s_Model_resetParam, __pyx_k_Model_resetParam, sizeof(__pyx_k_Model_resetParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_resetParams, __pyx_k_Model_resetParams, sizeof(__pyx_k_Model_resetParams), 0, 0, 1, 1}, + {&__pyx_n_s_Model_restartSolve, __pyx_k_Model_restartSolve, sizeof(__pyx_k_Model_restartSolve), 0, 0, 1, 1}, + {&__pyx_n_s_Model_separateSol, __pyx_k_Model_separateSol, sizeof(__pyx_k_Model_separateSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setBendersSubproblemIsConv, __pyx_k_Model_setBendersSubproblemIsConv, sizeof(__pyx_k_Model_setBendersSubproblemIsConv), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setBoolParam, __pyx_k_Model_setBoolParam, sizeof(__pyx_k_Model_setBoolParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setCharParam, __pyx_k_Model_setCharParam, sizeof(__pyx_k_Model_setCharParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setCheck, __pyx_k_Model_setCheck, sizeof(__pyx_k_Model_setCheck), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setEmphasis, __pyx_k_Model_setEmphasis, sizeof(__pyx_k_Model_setEmphasis), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setEnforced, __pyx_k_Model_setEnforced, sizeof(__pyx_k_Model_setEnforced), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setHeuristics, __pyx_k_Model_setHeuristics, sizeof(__pyx_k_Model_setHeuristics), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setInitial, __pyx_k_Model_setInitial, sizeof(__pyx_k_Model_setInitial), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setIntParam, __pyx_k_Model_setIntParam, sizeof(__pyx_k_Model_setIntParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setLogfile, __pyx_k_Model_setLogfile, sizeof(__pyx_k_Model_setLogfile), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setLongintParam, __pyx_k_Model_setLongintParam, sizeof(__pyx_k_Model_setLongintParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setMaximize, __pyx_k_Model_setMaximize, sizeof(__pyx_k_Model_setMaximize), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setMinimize, __pyx_k_Model_setMinimize, sizeof(__pyx_k_Model_setMinimize), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setObjIntegral, __pyx_k_Model_setObjIntegral, sizeof(__pyx_k_Model_setObjIntegral), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setObjective, __pyx_k_Model_setObjective, sizeof(__pyx_k_Model_setObjective), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setObjlimit, __pyx_k_Model_setObjlimit, sizeof(__pyx_k_Model_setObjlimit), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setParam, __pyx_k_Model_setParam, sizeof(__pyx_k_Model_setParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setParams, __pyx_k_Model_setParams, sizeof(__pyx_k_Model_setParams), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setParamsCountsols, __pyx_k_Model_setParamsCountsols, sizeof(__pyx_k_Model_setParamsCountsols), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setPresolve, __pyx_k_Model_setPresolve, sizeof(__pyx_k_Model_setPresolve), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setProbName, __pyx_k_Model_setProbName, sizeof(__pyx_k_Model_setProbName), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setRealParam, __pyx_k_Model_setRealParam, sizeof(__pyx_k_Model_setRealParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setRelaxSolVal, __pyx_k_Model_setRelaxSolVal, sizeof(__pyx_k_Model_setRelaxSolVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setRemovable, __pyx_k_Model_setRemovable, sizeof(__pyx_k_Model_setRemovable), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setSeparating, __pyx_k_Model_setSeparating, sizeof(__pyx_k_Model_setSeparating), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setSolVal, __pyx_k_Model_setSolVal, sizeof(__pyx_k_Model_setSolVal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setStringParam, __pyx_k_Model_setStringParam, sizeof(__pyx_k_Model_setStringParam), 0, 0, 1, 1}, + {&__pyx_n_s_Model_setupBendersSubproblem, __pyx_k_Model_setupBendersSubproblem, sizeof(__pyx_k_Model_setupBendersSubproblem), 0, 0, 1, 1}, + {&__pyx_n_s_Model_solveBendersSubproblem, __pyx_k_Model_solveBendersSubproblem, sizeof(__pyx_k_Model_solveBendersSubproblem), 0, 0, 1, 1}, + {&__pyx_n_s_Model_solveConcurrent, __pyx_k_Model_solveConcurrent, sizeof(__pyx_k_Model_solveConcurrent), 0, 0, 1, 1}, + {&__pyx_n_s_Model_solveDiveLP, __pyx_k_Model_solveDiveLP, sizeof(__pyx_k_Model_solveDiveLP), 0, 0, 1, 1}, + {&__pyx_n_s_Model_solveProbingLP, __pyx_k_Model_solveProbingLP, sizeof(__pyx_k_Model_solveProbingLP), 0, 0, 1, 1}, + {&__pyx_n_s_Model_startDive, __pyx_k_Model_startDive, sizeof(__pyx_k_Model_startDive), 0, 0, 1, 1}, + {&__pyx_n_s_Model_startProbing, __pyx_k_Model_startProbing, sizeof(__pyx_k_Model_startProbing), 0, 0, 1, 1}, + {&__pyx_n_s_Model_tightenVarLb, __pyx_k_Model_tightenVarLb, sizeof(__pyx_k_Model_tightenVarLb), 0, 0, 1, 1}, + {&__pyx_n_s_Model_tightenVarLbGlobal, __pyx_k_Model_tightenVarLbGlobal, sizeof(__pyx_k_Model_tightenVarLbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_tightenVarUb, __pyx_k_Model_tightenVarUb, sizeof(__pyx_k_Model_tightenVarUb), 0, 0, 1, 1}, + {&__pyx_n_s_Model_tightenVarUbGlobal, __pyx_k_Model_tightenVarUbGlobal, sizeof(__pyx_k_Model_tightenVarUbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_Model_to_ptr, __pyx_k_Model_to_ptr, sizeof(__pyx_k_Model_to_ptr), 0, 0, 1, 1}, + {&__pyx_n_s_Model_trySol, __pyx_k_Model_trySol, sizeof(__pyx_k_Model_trySol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_updateBendersLowerbounds, __pyx_k_Model_updateBendersLowerbounds, sizeof(__pyx_k_Model_updateBendersLowerbounds), 0, 0, 1, 1}, + {&__pyx_n_s_Model_updateNodeLowerbound, __pyx_k_Model_updateNodeLowerbound, sizeof(__pyx_k_Model_updateNodeLowerbound), 0, 0, 1, 1}, + {&__pyx_n_s_Model_version, __pyx_k_Model_version, sizeof(__pyx_k_Model_version), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeBestSol, __pyx_k_Model_writeBestSol, sizeof(__pyx_k_Model_writeBestSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeBestTransSol, __pyx_k_Model_writeBestTransSol, sizeof(__pyx_k_Model_writeBestTransSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeLP, __pyx_k_Model_writeLP, sizeof(__pyx_k_Model_writeLP), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeName, __pyx_k_Model_writeName, sizeof(__pyx_k_Model_writeName), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeParams, __pyx_k_Model_writeParams, sizeof(__pyx_k_Model_writeParams), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeProblem, __pyx_k_Model_writeProblem, sizeof(__pyx_k_Model_writeProblem), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeSol, __pyx_k_Model_writeSol, sizeof(__pyx_k_Model_writeSol), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeStatistics, __pyx_k_Model_writeStatistics, sizeof(__pyx_k_Model_writeStatistics), 0, 0, 1, 1}, + {&__pyx_n_s_Model_writeTransSol, __pyx_k_Model_writeTransSol, sizeof(__pyx_k_Model_writeTransSol), 0, 0, 1, 1}, + {&__pyx_n_s_NEWROUND, __pyx_k_NEWROUND, sizeof(__pyx_k_NEWROUND), 0, 0, 1, 1}, + {&__pyx_n_s_NLRow, __pyx_k_NLRow, sizeof(__pyx_k_NLRow), 0, 0, 1, 1}, + {&__pyx_n_s_NLRow___reduce_cython, __pyx_k_NLRow___reduce_cython, sizeof(__pyx_k_NLRow___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_NLRow___setstate_cython, __pyx_k_NLRow___setstate_cython, sizeof(__pyx_k_NLRow___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_NLRow_getConstant, __pyx_k_NLRow_getConstant, sizeof(__pyx_k_NLRow_getConstant), 0, 0, 1, 1}, + {&__pyx_n_s_NLRow_getDualsol, __pyx_k_NLRow_getDualsol, sizeof(__pyx_k_NLRow_getDualsol), 0, 0, 1, 1}, + {&__pyx_n_s_NLRow_getLhs, __pyx_k_NLRow_getLhs, sizeof(__pyx_k_NLRow_getLhs), 0, 0, 1, 1}, + {&__pyx_n_s_NLRow_getLinearTerms, __pyx_k_NLRow_getLinearTerms, sizeof(__pyx_k_NLRow_getLinearTerms), 0, 0, 1, 1}, + {&__pyx_n_s_NLRow_getRhs, __pyx_k_NLRow_getRhs, sizeof(__pyx_k_NLRow_getRhs), 0, 0, 1, 1}, + {&__pyx_n_s_NODEBRANCHED, __pyx_k_NODEBRANCHED, sizeof(__pyx_k_NODEBRANCHED), 0, 0, 1, 1}, + {&__pyx_n_s_NODEDELETE, __pyx_k_NODEDELETE, sizeof(__pyx_k_NODEDELETE), 0, 0, 1, 1}, + {&__pyx_n_s_NODEEVENT, __pyx_k_NODEEVENT, sizeof(__pyx_k_NODEEVENT), 0, 0, 1, 1}, + {&__pyx_n_s_NODEFEASIBLE, __pyx_k_NODEFEASIBLE, sizeof(__pyx_k_NODEFEASIBLE), 0, 0, 1, 1}, + {&__pyx_n_s_NODEFOCUSED, __pyx_k_NODEFOCUSED, sizeof(__pyx_k_NODEFOCUSED), 0, 0, 1, 1}, + {&__pyx_n_s_NODEINFEASIBLE, __pyx_k_NODEINFEASIBLE, sizeof(__pyx_k_NODEINFEASIBLE), 0, 0, 1, 1}, + {&__pyx_n_s_NODELIMIT, __pyx_k_NODELIMIT, sizeof(__pyx_k_NODELIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_NODESOLVED, __pyx_k_NODESOLVED, sizeof(__pyx_k_NODESOLVED), 0, 0, 1, 1}, + {&__pyx_n_s_NONE, __pyx_k_NONE, sizeof(__pyx_k_NONE), 0, 0, 1, 1}, + {&__pyx_n_s_NOTSOLVED, __pyx_k_NOTSOLVED, sizeof(__pyx_k_NOTSOLVED), 0, 0, 1, 1}, + {&__pyx_n_s_NUMERICS, __pyx_k_NUMERICS, sizeof(__pyx_k_NUMERICS), 0, 0, 1, 1}, + {&__pyx_n_s_Node, __pyx_k_Node, sizeof(__pyx_k_Node), 0, 0, 1, 1}, + {&__pyx_n_s_Node___reduce_cython, __pyx_k_Node___reduce_cython, sizeof(__pyx_k_Node___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Node___setstate_cython, __pyx_k_Node___setstate_cython, sizeof(__pyx_k_Node___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getAddedConss, __pyx_k_Node_getAddedConss, sizeof(__pyx_k_Node_getAddedConss), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getDepth, __pyx_k_Node_getDepth, sizeof(__pyx_k_Node_getDepth), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getDomchg, __pyx_k_Node_getDomchg, sizeof(__pyx_k_Node_getDomchg), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getEstimate, __pyx_k_Node_getEstimate, sizeof(__pyx_k_Node_getEstimate), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getLowerbound, __pyx_k_Node_getLowerbound, sizeof(__pyx_k_Node_getLowerbound), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getNAddedConss, __pyx_k_Node_getNAddedConss, sizeof(__pyx_k_Node_getNAddedConss), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getNDomchg, __pyx_k_Node_getNDomchg, sizeof(__pyx_k_Node_getNDomchg), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getNParentBranchings, __pyx_k_Node_getNParentBranchings, sizeof(__pyx_k_Node_getNParentBranchings), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getNumber, __pyx_k_Node_getNumber, sizeof(__pyx_k_Node_getNumber), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getParent, __pyx_k_Node_getParent, sizeof(__pyx_k_Node_getParent), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getParentBranchings, __pyx_k_Node_getParentBranchings, sizeof(__pyx_k_Node_getParentBranchings), 0, 0, 1, 1}, + {&__pyx_n_s_Node_getType, __pyx_k_Node_getType, sizeof(__pyx_k_Node_getType), 0, 0, 1, 1}, + {&__pyx_n_s_Node_isActive, __pyx_k_Node_isActive, sizeof(__pyx_k_Node_isActive), 0, 0, 1, 1}, + {&__pyx_n_s_Node_isPropagatedAgain, __pyx_k_Node_isPropagatedAgain, sizeof(__pyx_k_Node_isPropagatedAgain), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel, __pyx_k_Nodesel, sizeof(__pyx_k_Nodesel), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel___reduce_cython, __pyx_k_Nodesel___reduce_cython, sizeof(__pyx_k_Nodesel___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel___setstate_cython, __pyx_k_Nodesel___setstate_cython, sizeof(__pyx_k_Nodesel___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel_nodecomp, __pyx_k_Nodesel_nodecomp, sizeof(__pyx_k_Nodesel_nodecomp), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel_nodeexit, __pyx_k_Nodesel_nodeexit, sizeof(__pyx_k_Nodesel_nodeexit), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel_nodeexitsol, __pyx_k_Nodesel_nodeexitsol, sizeof(__pyx_k_Nodesel_nodeexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel_nodefree, __pyx_k_Nodesel_nodefree, sizeof(__pyx_k_Nodesel_nodefree), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel_nodeinit, __pyx_k_Nodesel_nodeinit, sizeof(__pyx_k_Nodesel_nodeinit), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel_nodeinitsol, __pyx_k_Nodesel_nodeinitsol, sizeof(__pyx_k_Nodesel_nodeinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Nodesel_nodeselect, __pyx_k_Nodesel_nodeselect, sizeof(__pyx_k_Nodesel_nodeselect), 0, 0, 1, 1}, + {&__pyx_kp_u_Nonlinear_objective_functions_ar, __pyx_k_Nonlinear_objective_functions_ar, sizeof(__pyx_k_Nonlinear_objective_functions_ar), 0, 1, 0, 0}, + {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, + {&__pyx_kp_u_Not_a_valid_parameter_name, __pyx_k_Not_a_valid_parameter_name, sizeof(__pyx_k_Not_a_valid_parameter_name), 0, 1, 0, 0}, + {&__pyx_n_s_OBJCHANGED, __pyx_k_OBJCHANGED, sizeof(__pyx_k_OBJCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_OBJLIMIT, __pyx_k_OBJLIMIT, sizeof(__pyx_k_OBJLIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_OFF, __pyx_k_OFF, sizeof(__pyx_k_OFF), 0, 0, 1, 1}, + {&__pyx_n_s_OPTIMAL, __pyx_k_OPTIMAL, sizeof(__pyx_k_OPTIMAL), 0, 0, 1, 1}, + {&__pyx_n_s_OPTIMALITY, __pyx_k_OPTIMALITY, sizeof(__pyx_k_OPTIMALITY), 0, 0, 1, 1}, + {&__pyx_n_u_ORcons, __pyx_k_ORcons, sizeof(__pyx_k_ORcons), 0, 1, 0, 1}, + {&__pyx_n_s_Op, __pyx_k_Op, sizeof(__pyx_k_Op), 0, 0, 1, 1}, + {&__pyx_n_s_Operator, __pyx_k_Operator, sizeof(__pyx_k_Operator), 0, 0, 1, 1}, + {&__pyx_n_s_PATCH, __pyx_k_PATCH, sizeof(__pyx_k_PATCH), 0, 0, 1, 1}, + {&__pyx_n_s_PHASEFEAS, __pyx_k_PHASEFEAS, sizeof(__pyx_k_PHASEFEAS), 0, 0, 1, 1}, + {&__pyx_n_s_PHASEIMPROVE, __pyx_k_PHASEIMPROVE, sizeof(__pyx_k_PHASEIMPROVE), 0, 0, 1, 1}, + {&__pyx_n_s_PHASEPROOF, __pyx_k_PHASEPROOF, sizeof(__pyx_k_PHASEPROOF), 0, 0, 1, 1}, + {&__pyx_n_s_POORSOLFOUND, __pyx_k_POORSOLFOUND, sizeof(__pyx_k_POORSOLFOUND), 0, 0, 1, 1}, + {&__pyx_n_s_PRESOLVED, __pyx_k_PRESOLVED, sizeof(__pyx_k_PRESOLVED), 0, 0, 1, 1}, + {&__pyx_n_s_PRESOLVEROUND, __pyx_k_PRESOLVEROUND, sizeof(__pyx_k_PRESOLVEROUND), 0, 0, 1, 1}, + {&__pyx_n_s_PRESOLVING, __pyx_k_PRESOLVING, sizeof(__pyx_k_PRESOLVING), 0, 0, 1, 1}, + {&__pyx_n_s_PRIMALLIMIT, __pyx_k_PRIMALLIMIT, sizeof(__pyx_k_PRIMALLIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_PROBINGNODE, __pyx_k_PROBINGNODE, sizeof(__pyx_k_PROBINGNODE), 0, 0, 1, 1}, + {&__pyx_n_s_PROBLEM, __pyx_k_PROBLEM, sizeof(__pyx_k_PROBLEM), 0, 0, 1, 1}, + {&__pyx_n_s_PSEUDO, __pyx_k_PSEUDO, sizeof(__pyx_k_PSEUDO), 0, 0, 1, 1}, + {&__pyx_n_s_PSEUDOFORK, __pyx_k_PSEUDOFORK, sizeof(__pyx_k_PSEUDOFORK), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_BENDERSENFOTYPE, __pyx_k_PY_SCIP_BENDERSENFOTYPE, sizeof(__pyx_k_PY_SCIP_BENDERSENFOTYPE), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___reduce, __pyx_k_PY_SCIP_BENDERSENFOTYPE___reduce, sizeof(__pyx_k_PY_SCIP_BENDERSENFOTYPE___reduce), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_BENDERSENFOTYPE___setsta, __pyx_k_PY_SCIP_BENDERSENFOTYPE___setsta, sizeof(__pyx_k_PY_SCIP_BENDERSENFOTYPE___setsta), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_BRANCHDIR, __pyx_k_PY_SCIP_BRANCHDIR, sizeof(__pyx_k_PY_SCIP_BRANCHDIR), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_BRANCHDIR___reduce_cytho, __pyx_k_PY_SCIP_BRANCHDIR___reduce_cytho, sizeof(__pyx_k_PY_SCIP_BRANCHDIR___reduce_cytho), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_BRANCHDIR___setstate_cyt, __pyx_k_PY_SCIP_BRANCHDIR___setstate_cyt, sizeof(__pyx_k_PY_SCIP_BRANCHDIR___setstate_cyt), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_CALL, __pyx_k_PY_SCIP_CALL, sizeof(__pyx_k_PY_SCIP_CALL), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_EVENTTYPE, __pyx_k_PY_SCIP_EVENTTYPE, sizeof(__pyx_k_PY_SCIP_EVENTTYPE), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_EVENTTYPE___reduce_cytho, __pyx_k_PY_SCIP_EVENTTYPE___reduce_cytho, sizeof(__pyx_k_PY_SCIP_EVENTTYPE___reduce_cytho), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_EVENTTYPE___setstate_cyt, __pyx_k_PY_SCIP_EVENTTYPE___setstate_cyt, sizeof(__pyx_k_PY_SCIP_EVENTTYPE___setstate_cyt), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_HEURTIMING, __pyx_k_PY_SCIP_HEURTIMING, sizeof(__pyx_k_PY_SCIP_HEURTIMING), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_HEURTIMING___reduce_cyth, __pyx_k_PY_SCIP_HEURTIMING___reduce_cyth, sizeof(__pyx_k_PY_SCIP_HEURTIMING___reduce_cyth), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_HEURTIMING___setstate_cy, __pyx_k_PY_SCIP_HEURTIMING___setstate_cy, sizeof(__pyx_k_PY_SCIP_HEURTIMING___setstate_cy), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_LPSOLSTAT, __pyx_k_PY_SCIP_LPSOLSTAT, sizeof(__pyx_k_PY_SCIP_LPSOLSTAT), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_LPSOLSTAT___reduce_cytho, __pyx_k_PY_SCIP_LPSOLSTAT___reduce_cytho, sizeof(__pyx_k_PY_SCIP_LPSOLSTAT___reduce_cytho), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_LPSOLSTAT___setstate_cyt, __pyx_k_PY_SCIP_LPSOLSTAT___setstate_cyt, sizeof(__pyx_k_PY_SCIP_LPSOLSTAT___setstate_cyt), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_NODETYPE, __pyx_k_PY_SCIP_NODETYPE, sizeof(__pyx_k_PY_SCIP_NODETYPE), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_NODETYPE___reduce_cython, __pyx_k_PY_SCIP_NODETYPE___reduce_cython, sizeof(__pyx_k_PY_SCIP_NODETYPE___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_NODETYPE___setstate_cyth, __pyx_k_PY_SCIP_NODETYPE___setstate_cyth, sizeof(__pyx_k_PY_SCIP_NODETYPE___setstate_cyth), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PARAMEMPHASIS, __pyx_k_PY_SCIP_PARAMEMPHASIS, sizeof(__pyx_k_PY_SCIP_PARAMEMPHASIS), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PARAMEMPHASIS___reduce_c, __pyx_k_PY_SCIP_PARAMEMPHASIS___reduce_c, sizeof(__pyx_k_PY_SCIP_PARAMEMPHASIS___reduce_c), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PARAMEMPHASIS___setstate, __pyx_k_PY_SCIP_PARAMEMPHASIS___setstate, sizeof(__pyx_k_PY_SCIP_PARAMEMPHASIS___setstate), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PARAMSETTING, __pyx_k_PY_SCIP_PARAMSETTING, sizeof(__pyx_k_PY_SCIP_PARAMSETTING), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PARAMSETTING___reduce_cy, __pyx_k_PY_SCIP_PARAMSETTING___reduce_cy, sizeof(__pyx_k_PY_SCIP_PARAMSETTING___reduce_cy), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PARAMSETTING___setstate, __pyx_k_PY_SCIP_PARAMSETTING___setstate, sizeof(__pyx_k_PY_SCIP_PARAMSETTING___setstate), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PRESOLTIMING, __pyx_k_PY_SCIP_PRESOLTIMING, sizeof(__pyx_k_PY_SCIP_PRESOLTIMING), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PRESOLTIMING___reduce_cy, __pyx_k_PY_SCIP_PRESOLTIMING___reduce_cy, sizeof(__pyx_k_PY_SCIP_PRESOLTIMING___reduce_cy), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PRESOLTIMING___setstate, __pyx_k_PY_SCIP_PRESOLTIMING___setstate, sizeof(__pyx_k_PY_SCIP_PRESOLTIMING___setstate), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PROPTIMING, __pyx_k_PY_SCIP_PROPTIMING, sizeof(__pyx_k_PY_SCIP_PROPTIMING), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PROPTIMING___reduce_cyth, __pyx_k_PY_SCIP_PROPTIMING___reduce_cyth, sizeof(__pyx_k_PY_SCIP_PROPTIMING___reduce_cyth), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_PROPTIMING___setstate_cy, __pyx_k_PY_SCIP_PROPTIMING___setstate_cy, sizeof(__pyx_k_PY_SCIP_PROPTIMING___setstate_cy), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_RESULT, __pyx_k_PY_SCIP_RESULT, sizeof(__pyx_k_PY_SCIP_RESULT), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_RESULT___reduce_cython, __pyx_k_PY_SCIP_RESULT___reduce_cython, sizeof(__pyx_k_PY_SCIP_RESULT___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_RESULT___setstate_cython, __pyx_k_PY_SCIP_RESULT___setstate_cython, sizeof(__pyx_k_PY_SCIP_RESULT___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_ROWORIGINTYPE, __pyx_k_PY_SCIP_ROWORIGINTYPE, sizeof(__pyx_k_PY_SCIP_ROWORIGINTYPE), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_ROWORIGINTYPE___reduce_c, __pyx_k_PY_SCIP_ROWORIGINTYPE___reduce_c, sizeof(__pyx_k_PY_SCIP_ROWORIGINTYPE___reduce_c), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_ROWORIGINTYPE___setstate, __pyx_k_PY_SCIP_ROWORIGINTYPE___setstate, sizeof(__pyx_k_PY_SCIP_ROWORIGINTYPE___setstate), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_STAGE, __pyx_k_PY_SCIP_STAGE, sizeof(__pyx_k_PY_SCIP_STAGE), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_STAGE___reduce_cython, __pyx_k_PY_SCIP_STAGE___reduce_cython, sizeof(__pyx_k_PY_SCIP_STAGE___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_STAGE___setstate_cython, __pyx_k_PY_SCIP_STAGE___setstate_cython, sizeof(__pyx_k_PY_SCIP_STAGE___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_STATUS, __pyx_k_PY_SCIP_STATUS, sizeof(__pyx_k_PY_SCIP_STATUS), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_STATUS___reduce_cython, __pyx_k_PY_SCIP_STATUS___reduce_cython, sizeof(__pyx_k_PY_SCIP_STATUS___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PY_SCIP_STATUS___setstate_cython, __pyx_k_PY_SCIP_STATUS___setstate_cython, sizeof(__pyx_k_PY_SCIP_STATUS___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_PowExpr, __pyx_k_PowExpr, sizeof(__pyx_k_PowExpr), 0, 0, 1, 1}, + {&__pyx_n_s_PowExpr___reduce_cython, __pyx_k_PowExpr___reduce_cython, sizeof(__pyx_k_PowExpr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_PowExpr___setstate_cython, __pyx_k_PowExpr___setstate_cython, sizeof(__pyx_k_PowExpr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Presol, __pyx_k_Presol, sizeof(__pyx_k_Presol), 0, 0, 1, 1}, + {&__pyx_n_s_Presol___reduce_cython, __pyx_k_Presol___reduce_cython, sizeof(__pyx_k_Presol___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Presol___setstate_cython, __pyx_k_Presol___setstate_cython, sizeof(__pyx_k_Presol___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Presol_presolexec, __pyx_k_Presol_presolexec, sizeof(__pyx_k_Presol_presolexec), 0, 0, 1, 1}, + {&__pyx_n_s_Presol_presolexit, __pyx_k_Presol_presolexit, sizeof(__pyx_k_Presol_presolexit), 0, 0, 1, 1}, + {&__pyx_n_s_Presol_presolexitpre, __pyx_k_Presol_presolexitpre, sizeof(__pyx_k_Presol_presolexitpre), 0, 0, 1, 1}, + {&__pyx_n_s_Presol_presolfree, __pyx_k_Presol_presolfree, sizeof(__pyx_k_Presol_presolfree), 0, 0, 1, 1}, + {&__pyx_n_s_Presol_presolinit, __pyx_k_Presol_presolinit, sizeof(__pyx_k_Presol_presolinit), 0, 0, 1, 1}, + {&__pyx_n_s_Presol_presolinitpre, __pyx_k_Presol_presolinitpre, sizeof(__pyx_k_Presol_presolinitpre), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer, __pyx_k_Pricer, sizeof(__pyx_k_Pricer), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer___reduce_cython, __pyx_k_Pricer___reduce_cython, sizeof(__pyx_k_Pricer___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer___setstate_cython, __pyx_k_Pricer___setstate_cython, sizeof(__pyx_k_Pricer___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer_pricerexit, __pyx_k_Pricer_pricerexit, sizeof(__pyx_k_Pricer_pricerexit), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer_pricerexitsol, __pyx_k_Pricer_pricerexitsol, sizeof(__pyx_k_Pricer_pricerexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer_pricerfarkas, __pyx_k_Pricer_pricerfarkas, sizeof(__pyx_k_Pricer_pricerfarkas), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer_pricerfree, __pyx_k_Pricer_pricerfree, sizeof(__pyx_k_Pricer_pricerfree), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer_pricerinit, __pyx_k_Pricer_pricerinit, sizeof(__pyx_k_Pricer_pricerinit), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer_pricerinitsol, __pyx_k_Pricer_pricerinitsol, sizeof(__pyx_k_Pricer_pricerinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Pricer_pricerredcost, __pyx_k_Pricer_pricerredcost, sizeof(__pyx_k_Pricer_pricerredcost), 0, 0, 1, 1}, + {&__pyx_n_s_ProdExpr, __pyx_k_ProdExpr, sizeof(__pyx_k_ProdExpr), 0, 0, 1, 1}, + {&__pyx_n_s_ProdExpr___reduce_cython, __pyx_k_ProdExpr___reduce_cython, sizeof(__pyx_k_ProdExpr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ProdExpr___setstate_cython, __pyx_k_ProdExpr___setstate_cython, sizeof(__pyx_k_ProdExpr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Prop, __pyx_k_Prop, sizeof(__pyx_k_Prop), 0, 0, 1, 1}, + {&__pyx_n_s_Prop___reduce_cython, __pyx_k_Prop___reduce_cython, sizeof(__pyx_k_Prop___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Prop___setstate_cython, __pyx_k_Prop___setstate_cython, sizeof(__pyx_k_Prop___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propexec, __pyx_k_Prop_propexec, sizeof(__pyx_k_Prop_propexec), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propexit, __pyx_k_Prop_propexit, sizeof(__pyx_k_Prop_propexit), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propexitpre, __pyx_k_Prop_propexitpre, sizeof(__pyx_k_Prop_propexitpre), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propexitsol, __pyx_k_Prop_propexitsol, sizeof(__pyx_k_Prop_propexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propfree, __pyx_k_Prop_propfree, sizeof(__pyx_k_Prop_propfree), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propinit, __pyx_k_Prop_propinit, sizeof(__pyx_k_Prop_propinit), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propinitpre, __pyx_k_Prop_propinitpre, sizeof(__pyx_k_Prop_propinitpre), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propinitsol, __pyx_k_Prop_propinitsol, sizeof(__pyx_k_Prop_propinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_proppresol, __pyx_k_Prop_proppresol, sizeof(__pyx_k_Prop_proppresol), 0, 0, 1, 1}, + {&__pyx_n_s_Prop_propresprop, __pyx_k_Prop_propresprop, sizeof(__pyx_k_Prop_propresprop), 0, 0, 1, 1}, + {&__pyx_kp_u_Provide_BOOLEAN_value_as_rhsvar, __pyx_k_Provide_BOOLEAN_value_as_rhsvar, sizeof(__pyx_k_Provide_BOOLEAN_value_as_rhsvar), 0, 1, 0, 0}, + {&__pyx_n_s_PyCons, __pyx_k_PyCons, sizeof(__pyx_k_PyCons), 0, 0, 1, 1}, + {&__pyx_n_s_PyRow, __pyx_k_PyRow, sizeof(__pyx_k_PyRow), 0, 0, 1, 1}, + {&__pyx_n_s_REDUCEDDOM, __pyx_k_REDUCEDDOM, sizeof(__pyx_k_REDUCEDDOM), 0, 0, 1, 1}, + {&__pyx_n_s_REFOCUSNODE, __pyx_k_REFOCUSNODE, sizeof(__pyx_k_REFOCUSNODE), 0, 0, 1, 1}, + {&__pyx_n_s_RELAX, __pyx_k_RELAX, sizeof(__pyx_k_RELAX), 0, 0, 1, 1}, + {&__pyx_n_s_REOPT, __pyx_k_REOPT, sizeof(__pyx_k_REOPT), 0, 0, 1, 1}, + {&__pyx_n_s_RESTARTLIMIT, __pyx_k_RESTARTLIMIT, sizeof(__pyx_k_RESTARTLIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_ROWADDEDLP, __pyx_k_ROWADDEDLP, sizeof(__pyx_k_ROWADDEDLP), 0, 0, 1, 1}, + {&__pyx_n_s_ROWADDEDSEPA, __pyx_k_ROWADDEDSEPA, sizeof(__pyx_k_ROWADDEDSEPA), 0, 0, 1, 1}, + {&__pyx_n_s_ROWCHANGED, __pyx_k_ROWCHANGED, sizeof(__pyx_k_ROWCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_ROWCOEFCHANGED, __pyx_k_ROWCOEFCHANGED, sizeof(__pyx_k_ROWCOEFCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_ROWCONSTCHANGED, __pyx_k_ROWCONSTCHANGED, sizeof(__pyx_k_ROWCONSTCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_ROWDELETEDLP, __pyx_k_ROWDELETEDLP, sizeof(__pyx_k_ROWDELETEDLP), 0, 0, 1, 1}, + {&__pyx_n_s_ROWDELETEDSEPA, __pyx_k_ROWDELETEDSEPA, sizeof(__pyx_k_ROWDELETEDSEPA), 0, 0, 1, 1}, + {&__pyx_n_s_ROWEVENT, __pyx_k_ROWEVENT, sizeof(__pyx_k_ROWEVENT), 0, 0, 1, 1}, + {&__pyx_n_s_ROWSIDECHANGED, __pyx_k_ROWSIDECHANGED, sizeof(__pyx_k_ROWSIDECHANGED), 0, 0, 1, 1}, + {&__pyx_kp_u_Ranged_ExprCons_is_not_well_defi, __pyx_k_Ranged_ExprCons_is_not_well_defi, sizeof(__pyx_k_Ranged_ExprCons_is_not_well_defi), 0, 1, 0, 0}, + {&__pyx_n_s_Reader, __pyx_k_Reader, sizeof(__pyx_k_Reader), 0, 0, 1, 1}, + {&__pyx_n_s_Reader___reduce_cython, __pyx_k_Reader___reduce_cython, sizeof(__pyx_k_Reader___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Reader___setstate_cython, __pyx_k_Reader___setstate_cython, sizeof(__pyx_k_Reader___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Reader_readerfree, __pyx_k_Reader_readerfree, sizeof(__pyx_k_Reader_readerfree), 0, 0, 1, 1}, + {&__pyx_n_s_Reader_readerread, __pyx_k_Reader_readerread, sizeof(__pyx_k_Reader_readerread), 0, 0, 1, 1}, + {&__pyx_n_s_Reader_readerwrite, __pyx_k_Reader_readerwrite, sizeof(__pyx_k_Reader_readerwrite), 0, 0, 1, 1}, + {&__pyx_n_s_Relax, __pyx_k_Relax, sizeof(__pyx_k_Relax), 0, 0, 1, 1}, + {&__pyx_n_s_Relax___reduce_cython, __pyx_k_Relax___reduce_cython, sizeof(__pyx_k_Relax___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Relax___setstate_cython, __pyx_k_Relax___setstate_cython, sizeof(__pyx_k_Relax___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Relax_relaxexec, __pyx_k_Relax_relaxexec, sizeof(__pyx_k_Relax_relaxexec), 0, 0, 1, 1}, + {&__pyx_n_s_Relax_relaxexit, __pyx_k_Relax_relaxexit, sizeof(__pyx_k_Relax_relaxexit), 0, 0, 1, 1}, + {&__pyx_n_s_Relax_relaxexitsol, __pyx_k_Relax_relaxexitsol, sizeof(__pyx_k_Relax_relaxexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Relax_relaxfree, __pyx_k_Relax_relaxfree, sizeof(__pyx_k_Relax_relaxfree), 0, 0, 1, 1}, + {&__pyx_n_s_Relax_relaxinit, __pyx_k_Relax_relaxinit, sizeof(__pyx_k_Relax_relaxinit), 0, 0, 1, 1}, + {&__pyx_n_s_Relax_relaxinitsol, __pyx_k_Relax_relaxinitsol, sizeof(__pyx_k_Relax_relaxinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Row, __pyx_k_Row, sizeof(__pyx_k_Row), 0, 0, 1, 1}, + {&__pyx_n_s_Row___reduce_cython, __pyx_k_Row___reduce_cython, sizeof(__pyx_k_Row___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Row___setstate_cython, __pyx_k_Row___setstate_cython, sizeof(__pyx_k_Row___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getBasisStatus, __pyx_k_Row_getBasisStatus, sizeof(__pyx_k_Row_getBasisStatus), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getCols, __pyx_k_Row_getCols, sizeof(__pyx_k_Row_getCols), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getConsOriginConshdlrtype, __pyx_k_Row_getConsOriginConshdlrtype, sizeof(__pyx_k_Row_getConsOriginConshdlrtype), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getConstant, __pyx_k_Row_getConstant, sizeof(__pyx_k_Row_getConstant), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getLPPos, __pyx_k_Row_getLPPos, sizeof(__pyx_k_Row_getLPPos), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getLhs, __pyx_k_Row_getLhs, sizeof(__pyx_k_Row_getLhs), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getNLPNonz, __pyx_k_Row_getNLPNonz, sizeof(__pyx_k_Row_getNLPNonz), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getNNonz, __pyx_k_Row_getNNonz, sizeof(__pyx_k_Row_getNNonz), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getNorm, __pyx_k_Row_getNorm, sizeof(__pyx_k_Row_getNorm), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getOrigintype, __pyx_k_Row_getOrigintype, sizeof(__pyx_k_Row_getOrigintype), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getRhs, __pyx_k_Row_getRhs, sizeof(__pyx_k_Row_getRhs), 0, 0, 1, 1}, + {&__pyx_n_s_Row_getVals, __pyx_k_Row_getVals, sizeof(__pyx_k_Row_getVals), 0, 0, 1, 1}, + {&__pyx_n_s_Row_isInGlobalCutpool, __pyx_k_Row_isInGlobalCutpool, sizeof(__pyx_k_Row_isInGlobalCutpool), 0, 0, 1, 1}, + {&__pyx_n_s_Row_isIntegral, __pyx_k_Row_isIntegral, sizeof(__pyx_k_Row_isIntegral), 0, 0, 1, 1}, + {&__pyx_n_s_Row_isLocal, __pyx_k_Row_isLocal, sizeof(__pyx_k_Row_isLocal), 0, 0, 1, 1}, + {&__pyx_n_s_Row_isModifiable, __pyx_k_Row_isModifiable, sizeof(__pyx_k_Row_isModifiable), 0, 0, 1, 1}, + {&__pyx_n_s_Row_isRemovable, __pyx_k_Row_isRemovable, sizeof(__pyx_k_Row_isRemovable), 0, 0, 1, 1}, + {&__pyx_n_s_SCIP_BOUNDTYPE_TO_STRING, __pyx_k_SCIP_BOUNDTYPE_TO_STRING, sizeof(__pyx_k_SCIP_BOUNDTYPE_TO_STRING), 0, 0, 1, 1}, + {&__pyx_kp_u_SCIP_a_required_plugin_was_not_f, __pyx_k_SCIP_a_required_plugin_was_not_f, sizeof(__pyx_k_SCIP_a_required_plugin_was_not_f), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_cannot_create_file, __pyx_k_SCIP_cannot_create_file, sizeof(__pyx_k_SCIP_cannot_create_file), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_does_not_support_nonlinear, __pyx_k_SCIP_does_not_support_nonlinear, sizeof(__pyx_k_SCIP_does_not_support_nonlinear), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_error_in_LP_solver, __pyx_k_SCIP_error_in_LP_solver, sizeof(__pyx_k_SCIP_error_in_LP_solver), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_error_in_input_data, __pyx_k_SCIP_error_in_input_data, sizeof(__pyx_k_SCIP_error_in_input_data), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_file_not_found_error, __pyx_k_SCIP_file_not_found_error, sizeof(__pyx_k_SCIP_file_not_found_error), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_insufficient_memory_error, __pyx_k_SCIP_insufficient_memory_error, sizeof(__pyx_k_SCIP_insufficient_memory_error), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_maximal_branching_depth_lev, __pyx_k_SCIP_maximal_branching_depth_lev, sizeof(__pyx_k_SCIP_maximal_branching_depth_lev), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_method_cannot_be_called_at, __pyx_k_SCIP_method_cannot_be_called_at, sizeof(__pyx_k_SCIP_method_cannot_be_called_at), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_method_returned_an_invalid, __pyx_k_SCIP_method_returned_an_invalid, sizeof(__pyx_k_SCIP_method_returned_an_invalid), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_no_problem_exists, __pyx_k_SCIP_no_problem_exists, sizeof(__pyx_k_SCIP_no_problem_exists), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_read_error, __pyx_k_SCIP_read_error, sizeof(__pyx_k_SCIP_read_error), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_reading_solution_from_file, __pyx_k_SCIP_reading_solution_from_file, sizeof(__pyx_k_SCIP_reading_solution_from_file), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_returned_base_status_zero_f, __pyx_k_SCIP_returned_base_status_zero_f, sizeof(__pyx_k_SCIP_returned_base_status_zero_f), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_returned_unknown_base_statu, __pyx_k_SCIP_returned_unknown_base_statu, sizeof(__pyx_k_SCIP_returned_unknown_base_statu), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_the_given_key_is_already_ex, __pyx_k_SCIP_the_given_key_is_already_ex, sizeof(__pyx_k_SCIP_the_given_key_is_already_ex), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_the_parameter_is_not_of_the, __pyx_k_SCIP_the_parameter_is_not_of_the, sizeof(__pyx_k_SCIP_the_parameter_is_not_of_the), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_the_parameter_with_the_give, __pyx_k_SCIP_the_parameter_with_the_give, sizeof(__pyx_k_SCIP_the_parameter_with_the_give), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_the_value_is_invalid_for_th, __pyx_k_SCIP_the_value_is_invalid_for_th, sizeof(__pyx_k_SCIP_the_value_is_invalid_for_th), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_unknown_return_code, __pyx_k_SCIP_unknown_return_code, sizeof(__pyx_k_SCIP_unknown_return_code), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_unspecified_error, __pyx_k_SCIP_unspecified_error, sizeof(__pyx_k_SCIP_unspecified_error), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_was_compiled_without_task_p, __pyx_k_SCIP_was_compiled_without_task_p, sizeof(__pyx_k_SCIP_was_compiled_without_task_p), 0, 1, 0, 0}, + {&__pyx_kp_u_SCIP_write_error, __pyx_k_SCIP_write_error, sizeof(__pyx_k_SCIP_write_error), 0, 1, 0, 0}, + {&__pyx_n_u_SCIPgetSolVal, __pyx_k_SCIPgetSolVal, sizeof(__pyx_k_SCIPgetSolVal), 0, 1, 0, 1}, + {&__pyx_n_s_SEPA, __pyx_k_SEPA, sizeof(__pyx_k_SEPA), 0, 0, 1, 1}, + {&__pyx_n_s_SEPARATED, __pyx_k_SEPARATED, sizeof(__pyx_k_SEPARATED), 0, 0, 1, 1}, + {&__pyx_n_s_SIBLING, __pyx_k_SIBLING, sizeof(__pyx_k_SIBLING), 0, 0, 1, 1}, + {&__pyx_n_s_SOLEVENT, __pyx_k_SOLEVENT, sizeof(__pyx_k_SOLEVENT), 0, 0, 1, 1}, + {&__pyx_n_s_SOLFOUND, __pyx_k_SOLFOUND, sizeof(__pyx_k_SOLFOUND), 0, 0, 1, 1}, + {&__pyx_n_s_SOLLIMIT, __pyx_k_SOLLIMIT, sizeof(__pyx_k_SOLLIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_SOLVED, __pyx_k_SOLVED, sizeof(__pyx_k_SOLVED), 0, 0, 1, 1}, + {&__pyx_n_s_SOLVELP, __pyx_k_SOLVELP, sizeof(__pyx_k_SOLVELP), 0, 0, 1, 1}, + {&__pyx_n_s_SOLVING, __pyx_k_SOLVING, sizeof(__pyx_k_SOLVING), 0, 0, 1, 1}, + {&__pyx_n_u_SOS1cons, __pyx_k_SOS1cons, sizeof(__pyx_k_SOS1cons), 0, 1, 0, 1}, + {&__pyx_n_u_SOS2cons, __pyx_k_SOS2cons, sizeof(__pyx_k_SOS2cons), 0, 1, 0, 1}, + {&__pyx_n_s_STALLNODELIMIT, __pyx_k_STALLNODELIMIT, sizeof(__pyx_k_STALLNODELIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_SUBROOT, __pyx_k_SUBROOT, sizeof(__pyx_k_SUBROOT), 0, 0, 1, 1}, + {&__pyx_n_s_SUCCESS, __pyx_k_SUCCESS, sizeof(__pyx_k_SUCCESS), 0, 0, 1, 1}, + {&__pyx_n_s_SUSPENDED, __pyx_k_SUSPENDED, sizeof(__pyx_k_SUSPENDED), 0, 0, 1, 1}, + {&__pyx_n_s_SYNC, __pyx_k_SYNC, sizeof(__pyx_k_SYNC), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa, __pyx_k_Sepa, sizeof(__pyx_k_Sepa), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa___reduce_cython, __pyx_k_Sepa___reduce_cython, sizeof(__pyx_k_Sepa___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa___setstate_cython, __pyx_k_Sepa___setstate_cython, sizeof(__pyx_k_Sepa___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa_sepaexeclp, __pyx_k_Sepa_sepaexeclp, sizeof(__pyx_k_Sepa_sepaexeclp), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa_sepaexecsol, __pyx_k_Sepa_sepaexecsol, sizeof(__pyx_k_Sepa_sepaexecsol), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa_sepaexit, __pyx_k_Sepa_sepaexit, sizeof(__pyx_k_Sepa_sepaexit), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa_sepaexitsol, __pyx_k_Sepa_sepaexitsol, sizeof(__pyx_k_Sepa_sepaexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa_sepafree, __pyx_k_Sepa_sepafree, sizeof(__pyx_k_Sepa_sepafree), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa_sepainit, __pyx_k_Sepa_sepainit, sizeof(__pyx_k_Sepa_sepainit), 0, 0, 1, 1}, + {&__pyx_n_s_Sepa_sepainitsol, __pyx_k_Sepa_sepainitsol, sizeof(__pyx_k_Sepa_sepainitsol), 0, 0, 1, 1}, + {&__pyx_n_s_Solution, __pyx_k_Solution, sizeof(__pyx_k_Solution), 0, 0, 1, 1}, + {&__pyx_n_s_Solution___reduce_cython, __pyx_k_Solution___reduce_cython, sizeof(__pyx_k_Solution___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Solution___setstate_cython, __pyx_k_Solution___setstate_cython, sizeof(__pyx_k_Solution___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Solution__checkStage, __pyx_k_Solution__checkStage, sizeof(__pyx_k_Solution__checkStage), 0, 0, 1, 1}, + {&__pyx_n_s_Solution__evaluate, __pyx_k_Solution__evaluate, sizeof(__pyx_k_Solution__evaluate), 0, 0, 1, 1}, + {&__pyx_n_s_StageNames, __pyx_k_StageNames, sizeof(__pyx_k_StageNames), 0, 0, 1, 1}, + {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1}, + {&__pyx_n_s_SumExpr, __pyx_k_SumExpr, sizeof(__pyx_k_SumExpr), 0, 0, 1, 1}, + {&__pyx_n_s_SumExpr___reduce_cython, __pyx_k_SumExpr___reduce_cython, sizeof(__pyx_k_SumExpr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_SumExpr___setstate_cython, __pyx_k_SumExpr___setstate_cython, sizeof(__pyx_k_SumExpr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_TIMELIMIT, __pyx_k_TIMELIMIT, sizeof(__pyx_k_TIMELIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_TOTALNODELIMIT, __pyx_k_TOTALNODELIMIT, sizeof(__pyx_k_TOTALNODELIMIT), 0, 0, 1, 1}, + {&__pyx_n_s_TRANSFORMED, __pyx_k_TRANSFORMED, sizeof(__pyx_k_TRANSFORMED), 0, 0, 1, 1}, + {&__pyx_n_s_TRANSFORMING, __pyx_k_TRANSFORMING, sizeof(__pyx_k_TRANSFORMING), 0, 0, 1, 1}, + {&__pyx_n_s_Term, __pyx_k_Term, sizeof(__pyx_k_Term), 0, 0, 1, 1}, + {&__pyx_n_s_Term___add, __pyx_k_Term___add, sizeof(__pyx_k_Term___add), 0, 0, 1, 1}, + {&__pyx_n_s_Term___eq, __pyx_k_Term___eq, sizeof(__pyx_k_Term___eq), 0, 0, 1, 1}, + {&__pyx_n_s_Term___getitem, __pyx_k_Term___getitem, sizeof(__pyx_k_Term___getitem), 0, 0, 1, 1}, + {&__pyx_n_s_Term___hash, __pyx_k_Term___hash, sizeof(__pyx_k_Term___hash), 0, 0, 1, 1}, + {&__pyx_n_s_Term___init, __pyx_k_Term___init, sizeof(__pyx_k_Term___init), 0, 0, 1, 1}, + {&__pyx_n_s_Term___init___locals_genexpr, __pyx_k_Term___init___locals_genexpr, sizeof(__pyx_k_Term___init___locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_Term___init___locals_lambda, __pyx_k_Term___init___locals_lambda, sizeof(__pyx_k_Term___init___locals_lambda), 0, 0, 1, 1}, + {&__pyx_n_s_Term___len, __pyx_k_Term___len, sizeof(__pyx_k_Term___len), 0, 0, 1, 1}, + {&__pyx_n_s_Term___repr, __pyx_k_Term___repr, sizeof(__pyx_k_Term___repr), 0, 0, 1, 1}, + {&__pyx_kp_u_Term_s, __pyx_k_Term_s, sizeof(__pyx_k_Term_s), 0, 1, 0, 0}, + {&__pyx_kp_u_The_constraint_handler_s_does_no, __pyx_k_The_constraint_handler_s_does_no, sizeof(__pyx_k_The_constraint_handler_s_does_no), 0, 1, 0, 0}, + {&__pyx_kp_u_The_given_capsule_does_not_conta, __pyx_k_The_given_capsule_does_not_conta, sizeof(__pyx_k_The_given_capsule_does_not_conta), 0, 1, 0, 0}, + {&__pyx_kp_u_The_given_variable_is_not_a_pyva, __pyx_k_The_given_variable_is_not_a_pyva, sizeof(__pyx_k_The_given_variable_is_not_a_pyva), 0, 1, 0, 0}, + {&__pyx_kp_u_The_problem_does_not_have_a_prim, __pyx_k_The_problem_does_not_have_a_prim, sizeof(__pyx_k_The_problem_does_not_have_a_prim), 0, 1, 0, 0}, + {&__pyx_kp_s_This_is_a_monomial_term, __pyx_k_This_is_a_monomial_term, sizeof(__pyx_k_This_is_a_monomial_term), 0, 0, 1, 0}, + {&__pyx_kp_u_To_create_a_solution_you_should, __pyx_k_To_create_a_solution_you_should, sizeof(__pyx_k_To_create_a_solution_you_should), 0, 1, 0, 0}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_UBCHANGED, __pyx_k_UBCHANGED, sizeof(__pyx_k_UBCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_UBRELAXED, __pyx_k_UBRELAXED, sizeof(__pyx_k_UBRELAXED), 0, 0, 1, 1}, + {&__pyx_n_s_UBTIGHTENED, __pyx_k_UBTIGHTENED, sizeof(__pyx_k_UBTIGHTENED), 0, 0, 1, 1}, + {&__pyx_n_s_UNBOUNDED, __pyx_k_UNBOUNDED, sizeof(__pyx_k_UNBOUNDED), 0, 0, 1, 1}, + {&__pyx_n_s_UNBOUNDEDRAY, __pyx_k_UNBOUNDEDRAY, sizeof(__pyx_k_UNBOUNDEDRAY), 0, 0, 1, 1}, + {&__pyx_n_s_UNKNOWN, __pyx_k_UNKNOWN, sizeof(__pyx_k_UNKNOWN), 0, 0, 1, 1}, + {&__pyx_n_s_UNSPEC, __pyx_k_UNSPEC, sizeof(__pyx_k_UNSPEC), 0, 0, 1, 1}, + {&__pyx_n_s_UPWARDS, __pyx_k_UPWARDS, sizeof(__pyx_k_UPWARDS), 0, 0, 1, 1}, + {&__pyx_n_s_USERINTERRUPT, __pyx_k_USERINTERRUPT, sizeof(__pyx_k_USERINTERRUPT), 0, 0, 1, 1}, + {&__pyx_n_s_UnaryExpr, __pyx_k_UnaryExpr, sizeof(__pyx_k_UnaryExpr), 0, 0, 1, 1}, + {&__pyx_n_s_UnaryExpr___reduce_cython, __pyx_k_UnaryExpr___reduce_cython, sizeof(__pyx_k_UnaryExpr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_UnaryExpr___setstate_cython, __pyx_k_UnaryExpr___setstate_cython, sizeof(__pyx_k_UnaryExpr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Union, __pyx_k_Union, sizeof(__pyx_k_Union), 0, 0, 1, 1}, + {&__pyx_kp_s_Union_Expr_GenExpr, __pyx_k_Union_Expr_GenExpr, sizeof(__pyx_k_Union_Expr_GenExpr), 0, 0, 1, 0}, + {&__pyx_n_s_VARADDED, __pyx_k_VARADDED, sizeof(__pyx_k_VARADDED), 0, 0, 1, 1}, + {&__pyx_n_s_VARCHANGED, __pyx_k_VARCHANGED, sizeof(__pyx_k_VARCHANGED), 0, 0, 1, 1}, + {&__pyx_n_s_VARDELETED, __pyx_k_VARDELETED, sizeof(__pyx_k_VARDELETED), 0, 0, 1, 1}, + {&__pyx_n_s_VAREVENT, __pyx_k_VAREVENT, sizeof(__pyx_k_VAREVENT), 0, 0, 1, 1}, + {&__pyx_n_s_VARFIXED, __pyx_k_VARFIXED, sizeof(__pyx_k_VARFIXED), 0, 0, 1, 1}, + {&__pyx_n_s_VARUNLOCKED, __pyx_k_VARUNLOCKED, sizeof(__pyx_k_VARUNLOCKED), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_VarExpr, __pyx_k_VarExpr, sizeof(__pyx_k_VarExpr), 0, 0, 1, 1}, + {&__pyx_n_s_VarExpr___reduce_cython, __pyx_k_VarExpr___reduce_cython, sizeof(__pyx_k_VarExpr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_VarExpr___setstate_cython, __pyx_k_VarExpr___setstate_cython, sizeof(__pyx_k_VarExpr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Variable, __pyx_k_Variable, sizeof(__pyx_k_Variable), 0, 0, 1, 1}, + {&__pyx_n_s_Variable___reduce_cython, __pyx_k_Variable___reduce_cython, sizeof(__pyx_k_Variable___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Variable___setstate_cython, __pyx_k_Variable___setstate_cython, sizeof(__pyx_k_Variable___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getCol, __pyx_k_Variable_getCol, sizeof(__pyx_k_Variable_getCol), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getIndex, __pyx_k_Variable_getIndex, sizeof(__pyx_k_Variable_getIndex), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getLPSol, __pyx_k_Variable_getLPSol, sizeof(__pyx_k_Variable_getLPSol), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getLbGlobal, __pyx_k_Variable_getLbGlobal, sizeof(__pyx_k_Variable_getLbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getLbLocal, __pyx_k_Variable_getLbLocal, sizeof(__pyx_k_Variable_getLbLocal), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getLbOriginal, __pyx_k_Variable_getLbOriginal, sizeof(__pyx_k_Variable_getLbOriginal), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getObj, __pyx_k_Variable_getObj, sizeof(__pyx_k_Variable_getObj), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getUbGlobal, __pyx_k_Variable_getUbGlobal, sizeof(__pyx_k_Variable_getUbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getUbLocal, __pyx_k_Variable_getUbLocal, sizeof(__pyx_k_Variable_getUbLocal), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_getUbOriginal, __pyx_k_Variable_getUbOriginal, sizeof(__pyx_k_Variable_getUbOriginal), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_isInLP, __pyx_k_Variable_isInLP, sizeof(__pyx_k_Variable_isInLP), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_isOriginal, __pyx_k_Variable_isOriginal, sizeof(__pyx_k_Variable_isOriginal), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_ptr, __pyx_k_Variable_ptr, sizeof(__pyx_k_Variable_ptr), 0, 0, 1, 1}, + {&__pyx_n_s_Variable_vtype, __pyx_k_Variable_vtype, sizeof(__pyx_k_Variable_vtype), 0, 0, 1, 1}, + {&__pyx_n_s_Warning, __pyx_k_Warning, sizeof(__pyx_k_Warning), 0, 0, 1, 1}, + {&__pyx_n_u_XORcons, __pyx_k_XORcons, sizeof(__pyx_k_XORcons), 0, 1, 0, 1}, + {&__pyx_n_s_ZeroDivisionError, __pyx_k_ZeroDivisionError, sizeof(__pyx_k_ZeroDivisionError), 0, 0, 1, 1}, + {&__pyx_kp_u__10, __pyx_k__10, sizeof(__pyx_k__10), 0, 1, 0, 0}, + {&__pyx_kp_u__114, __pyx_k__114, sizeof(__pyx_k__114), 0, 1, 0, 0}, + {&__pyx_n_s__1188, __pyx_k__1188, sizeof(__pyx_k__1188), 0, 0, 1, 1}, + {&__pyx_n_s__126, __pyx_k__126, sizeof(__pyx_k__126), 0, 0, 1, 1}, + {&__pyx_kp_u__126, __pyx_k__126, sizeof(__pyx_k__126), 0, 1, 0, 0}, + {&__pyx_kp_u__162, __pyx_k__162, sizeof(__pyx_k__162), 0, 1, 0, 0}, + {&__pyx_kp_u__163, __pyx_k__163, sizeof(__pyx_k__163), 0, 1, 0, 0}, + {&__pyx_kp_u__164, __pyx_k__164, sizeof(__pyx_k__164), 0, 1, 0, 0}, + {&__pyx_kp_u__165, __pyx_k__165, sizeof(__pyx_k__165), 0, 1, 0, 0}, + {&__pyx_kp_u__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 1, 0, 0}, + {&__pyx_kp_u__441, __pyx_k__441, sizeof(__pyx_k__441), 0, 1, 0, 0}, + {&__pyx_kp_u__442, __pyx_k__442, sizeof(__pyx_k__442), 0, 1, 0, 0}, + {&__pyx_kp_u__6, __pyx_k__6, sizeof(__pyx_k__6), 0, 1, 0, 0}, + {&__pyx_kp_u__79, __pyx_k__79, sizeof(__pyx_k__79), 0, 1, 0, 0}, + {&__pyx_kp_u__89, __pyx_k__89, sizeof(__pyx_k__89), 0, 1, 0, 0}, + {&__pyx_kp_u__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 1, 0, 0}, + {&__pyx_n_u__94, __pyx_k__94, sizeof(__pyx_k__94), 0, 1, 0, 1}, + {&__pyx_n_u_abs, __pyx_k_abs, sizeof(__pyx_k_abs), 0, 1, 0, 1}, + {&__pyx_n_s_absfile, __pyx_k_absfile, sizeof(__pyx_k_absfile), 0, 0, 1, 1}, + {&__pyx_n_s_abspath, __pyx_k_abspath, sizeof(__pyx_k_abspath), 0, 0, 1, 1}, + {&__pyx_n_s_activateBenders, __pyx_k_activateBenders, sizeof(__pyx_k_activateBenders), 0, 0, 1, 1}, + {&__pyx_n_s_activeone, __pyx_k_activeone, sizeof(__pyx_k_activeone), 0, 0, 1, 1}, + {&__pyx_n_s_activity, __pyx_k_activity, sizeof(__pyx_k_activity), 0, 0, 1, 1}, + {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1}, + {&__pyx_n_s_addBendersSubproblem, __pyx_k_addBendersSubproblem, sizeof(__pyx_k_addBendersSubproblem), 0, 0, 1, 1}, + {&__pyx_n_s_addCoefLinear, __pyx_k_addCoefLinear, sizeof(__pyx_k_addCoefLinear), 0, 0, 1, 1}, + {&__pyx_n_s_addCol, __pyx_k_addCol, sizeof(__pyx_k_addCol), 0, 0, 1, 1}, + {&__pyx_n_s_addCols, __pyx_k_addCols, sizeof(__pyx_k_addCols), 0, 0, 1, 1}, + {&__pyx_n_s_addCols_locals_genexpr, __pyx_k_addCols_locals_genexpr, sizeof(__pyx_k_addCols_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_addCons, __pyx_k_addCons, sizeof(__pyx_k_addCons), 0, 0, 1, 1}, + {&__pyx_n_s_addConsAnd, __pyx_k_addConsAnd, sizeof(__pyx_k_addConsAnd), 0, 0, 1, 1}, + {&__pyx_n_s_addConsCardinality, __pyx_k_addConsCardinality, sizeof(__pyx_k_addConsCardinality), 0, 0, 1, 1}, + {&__pyx_n_s_addConsCoeff, __pyx_k_addConsCoeff, sizeof(__pyx_k_addConsCoeff), 0, 0, 1, 1}, + {&__pyx_n_s_addConsDisjunction, __pyx_k_addConsDisjunction, sizeof(__pyx_k_addConsDisjunction), 0, 0, 1, 1}, + {&__pyx_n_s_addConsDisjunction_locals_ensure, __pyx_k_addConsDisjunction_locals_ensure, sizeof(__pyx_k_addConsDisjunction_locals_ensure), 0, 0, 1, 1}, + {&__pyx_n_s_addConsElemDisjunction, __pyx_k_addConsElemDisjunction, sizeof(__pyx_k_addConsElemDisjunction), 0, 0, 1, 1}, + {&__pyx_n_s_addConsIndicator, __pyx_k_addConsIndicator, sizeof(__pyx_k_addConsIndicator), 0, 0, 1, 1}, + {&__pyx_n_s_addConsLocal, __pyx_k_addConsLocal, sizeof(__pyx_k_addConsLocal), 0, 0, 1, 1}, + {&__pyx_n_s_addConsNode, __pyx_k_addConsNode, sizeof(__pyx_k_addConsNode), 0, 0, 1, 1}, + {&__pyx_n_s_addConsOr, __pyx_k_addConsOr, sizeof(__pyx_k_addConsOr), 0, 0, 1, 1}, + {&__pyx_n_s_addConsSOS1, __pyx_k_addConsSOS1, sizeof(__pyx_k_addConsSOS1), 0, 0, 1, 1}, + {&__pyx_n_s_addConsSOS2, __pyx_k_addConsSOS2, sizeof(__pyx_k_addConsSOS2), 0, 0, 1, 1}, + {&__pyx_n_s_addConsXor, __pyx_k_addConsXor, sizeof(__pyx_k_addConsXor), 0, 0, 1, 1}, + {&__pyx_n_s_addConss, __pyx_k_addConss, sizeof(__pyx_k_addConss), 0, 0, 1, 1}, + {&__pyx_n_s_addConss_locals_ensure_iterable, __pyx_k_addConss_locals_ensure_iterable, sizeof(__pyx_k_addConss_locals_ensure_iterable), 0, 0, 1, 1}, + {&__pyx_n_s_addCut, __pyx_k_addCut, sizeof(__pyx_k_addCut), 0, 0, 1, 1}, + {&__pyx_n_s_addExprNonlinear, __pyx_k_addExprNonlinear, sizeof(__pyx_k_addExprNonlinear), 0, 0, 1, 1}, + {&__pyx_kp_u_addExprNonlinear_can_only_be_cal, __pyx_k_addExprNonlinear_can_only_be_cal, sizeof(__pyx_k_addExprNonlinear_can_only_be_cal), 0, 1, 0, 0}, + {&__pyx_kp_u_addExprNonlinear_cannot_be_calle, __pyx_k_addExprNonlinear_cannot_be_calle, sizeof(__pyx_k_addExprNonlinear_cannot_be_calle), 0, 1, 0, 0}, + {&__pyx_n_s_addObjoffset, __pyx_k_addObjoffset, sizeof(__pyx_k_addObjoffset), 0, 0, 1, 1}, + {&__pyx_n_s_addPoolCut, __pyx_k_addPoolCut, sizeof(__pyx_k_addPoolCut), 0, 0, 1, 1}, + {&__pyx_n_s_addPyCons, __pyx_k_addPyCons, sizeof(__pyx_k_addPyCons), 0, 0, 1, 1}, + {&__pyx_n_s_addRow, __pyx_k_addRow, sizeof(__pyx_k_addRow), 0, 0, 1, 1}, + {&__pyx_n_s_addRowDive, __pyx_k_addRowDive, sizeof(__pyx_k_addRowDive), 0, 0, 1, 1}, + {&__pyx_n_s_addRows, __pyx_k_addRows, sizeof(__pyx_k_addRows), 0, 0, 1, 1}, + {&__pyx_n_s_addRows_locals_genexpr, __pyx_k_addRows_locals_genexpr, sizeof(__pyx_k_addRows_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_addSol, __pyx_k_addSol, sizeof(__pyx_k_addSol), 0, 0, 1, 1}, + {&__pyx_n_s_addVar, __pyx_k_addVar, sizeof(__pyx_k_addVar), 0, 0, 1, 1}, + {&__pyx_n_s_addVarLocks, __pyx_k_addVarLocks, sizeof(__pyx_k_addVarLocks), 0, 0, 1, 1}, + {&__pyx_n_s_addVarSOS1, __pyx_k_addVarSOS1, sizeof(__pyx_k_addVarSOS1), 0, 0, 1, 1}, + {&__pyx_n_s_addVarSOS2, __pyx_k_addVarSOS2, sizeof(__pyx_k_addVarSOS2), 0, 0, 1, 1}, + {&__pyx_n_s_addVarToRow, __pyx_k_addVarToRow, sizeof(__pyx_k_addVarToRow), 0, 0, 1, 1}, + {&__pyx_n_s_add_2, __pyx_k_add_2, sizeof(__pyx_k_add_2), 0, 0, 1, 1}, + {&__pyx_n_s_addedconss, __pyx_k_addedconss, sizeof(__pyx_k_addedconss), 0, 0, 1, 1}, + {&__pyx_n_s_addedconsssize, __pyx_k_addedconsssize, sizeof(__pyx_k_addedconsssize), 0, 0, 1, 1}, + {&__pyx_n_s_allowaddcons, __pyx_k_allowaddcons, sizeof(__pyx_k_allowaddcons), 0, 0, 1, 1}, + {&__pyx_n_s_allowlocal, __pyx_k_allowlocal, sizeof(__pyx_k_allowlocal), 0, 0, 1, 1}, + {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, + {&__pyx_n_s_appendVarSOS1, __pyx_k_appendVarSOS1, sizeof(__pyx_k_appendVarSOS1), 0, 0, 1, 1}, + {&__pyx_n_s_appendVarSOS2, __pyx_k_appendVarSOS2, sizeof(__pyx_k_appendVarSOS2), 0, 0, 1, 1}, + {&__pyx_n_s_applyCutsProbing, __pyx_k_applyCutsProbing, sizeof(__pyx_k_applyCutsProbing), 0, 0, 1, 1}, + {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_attr, __pyx_k_attr, sizeof(__pyx_k_attr), 0, 0, 1, 1}, + {&__pyx_n_s_auxvar, __pyx_k_auxvar, sizeof(__pyx_k_auxvar), 0, 0, 1, 1}, + {&__pyx_n_s_auxvar_2, __pyx_k_auxvar_2, sizeof(__pyx_k_auxvar_2), 0, 0, 1, 1}, + {&__pyx_n_u_auxviol, __pyx_k_auxviol, sizeof(__pyx_k_auxviol), 0, 1, 0, 1}, + {&__pyx_n_s_backtrackProbing, __pyx_k_backtrackProbing, sizeof(__pyx_k_backtrackProbing), 0, 0, 1, 1}, + {&__pyx_n_u_basic, __pyx_k_basic, sizeof(__pyx_k_basic), 0, 1, 0, 1}, + {&__pyx_n_s_bdtype, __pyx_k_bdtype, sizeof(__pyx_k_bdtype), 0, 0, 1, 1}, + {&__pyx_n_s_beg, __pyx_k_beg, sizeof(__pyx_k_beg), 0, 0, 1, 1}, + {&__pyx_n_s_benders, __pyx_k_benders, sizeof(__pyx_k_benders), 0, 0, 1, 1}, + {&__pyx_n_s_benders_2, __pyx_k_benders_2, sizeof(__pyx_k_benders_2), 0, 0, 1, 1}, + {&__pyx_n_s_benderscreatesub, __pyx_k_benderscreatesub, sizeof(__pyx_k_benderscreatesub), 0, 0, 1, 1}, + {&__pyx_n_s_benderscut, __pyx_k_benderscut, sizeof(__pyx_k_benderscut), 0, 0, 1, 1}, + {&__pyx_n_s_benderscutexec, __pyx_k_benderscutexec, sizeof(__pyx_k_benderscutexec), 0, 0, 1, 1}, + {&__pyx_n_s_benderscutexit, __pyx_k_benderscutexit, sizeof(__pyx_k_benderscutexit), 0, 0, 1, 1}, + {&__pyx_n_s_benderscutexitsol, __pyx_k_benderscutexitsol, sizeof(__pyx_k_benderscutexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_benderscutfree, __pyx_k_benderscutfree, sizeof(__pyx_k_benderscutfree), 0, 0, 1, 1}, + {&__pyx_n_s_benderscutinit, __pyx_k_benderscutinit, sizeof(__pyx_k_benderscutinit), 0, 0, 1, 1}, + {&__pyx_n_s_benderscutinitsol, __pyx_k_benderscutinitsol, sizeof(__pyx_k_benderscutinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_bendersexit, __pyx_k_bendersexit, sizeof(__pyx_k_bendersexit), 0, 0, 1, 1}, + {&__pyx_n_s_bendersexitpre, __pyx_k_bendersexitpre, sizeof(__pyx_k_bendersexitpre), 0, 0, 1, 1}, + {&__pyx_n_s_bendersexitsol, __pyx_k_bendersexitsol, sizeof(__pyx_k_bendersexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_bendersfree, __pyx_k_bendersfree, sizeof(__pyx_k_bendersfree), 0, 0, 1, 1}, + {&__pyx_n_s_bendersfreesub, __pyx_k_bendersfreesub, sizeof(__pyx_k_bendersfreesub), 0, 0, 1, 1}, + {&__pyx_n_s_bendersgetvar, __pyx_k_bendersgetvar, sizeof(__pyx_k_bendersgetvar), 0, 0, 1, 1}, + {&__pyx_n_s_bendersinit, __pyx_k_bendersinit, sizeof(__pyx_k_bendersinit), 0, 0, 1, 1}, + {&__pyx_n_s_bendersinitpre, __pyx_k_bendersinitpre, sizeof(__pyx_k_bendersinitpre), 0, 0, 1, 1}, + {&__pyx_n_s_bendersinitsol, __pyx_k_bendersinitsol, sizeof(__pyx_k_bendersinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_benderspostsolve, __pyx_k_benderspostsolve, sizeof(__pyx_k_benderspostsolve), 0, 0, 1, 1}, + {&__pyx_n_s_benderspresubsolve, __pyx_k_benderspresubsolve, sizeof(__pyx_k_benderspresubsolve), 0, 0, 1, 1}, + {&__pyx_n_s_benderssolvesub, __pyx_k_benderssolvesub, sizeof(__pyx_k_benderssolvesub), 0, 0, 1, 1}, + {&__pyx_n_s_benderssolvesubconvex, __pyx_k_benderssolvesubconvex, sizeof(__pyx_k_benderssolvesubconvex), 0, 0, 1, 1}, + {&__pyx_n_u_bestsollimit, __pyx_k_bestsollimit, sizeof(__pyx_k_bestsollimit), 0, 1, 0, 1}, + {&__pyx_n_s_bilincoef, __pyx_k_bilincoef, sizeof(__pyx_k_bilincoef), 0, 0, 1, 1}, + {&__pyx_n_s_bilinterm1, __pyx_k_bilinterm1, sizeof(__pyx_k_bilinterm1), 0, 0, 1, 1}, + {&__pyx_n_s_bilinterm2, __pyx_k_bilinterm2, sizeof(__pyx_k_bilinterm2), 0, 0, 1, 1}, + {&__pyx_n_s_bilinterms, __pyx_k_bilinterms, sizeof(__pyx_k_bilinterms), 0, 0, 1, 1}, + {&__pyx_n_s_binVar, __pyx_k_binVar, sizeof(__pyx_k_binVar), 0, 0, 1, 1}, + {&__pyx_n_s_binds, __pyx_k_binds, sizeof(__pyx_k_binds), 0, 0, 1, 1}, + {&__pyx_n_s_binvar, __pyx_k_binvar, sizeof(__pyx_k_binvar), 0, 0, 1, 1}, + {&__pyx_n_s_binvars, __pyx_k_binvars, sizeof(__pyx_k_binvars), 0, 0, 1, 1}, + {&__pyx_n_s_both, __pyx_k_both, sizeof(__pyx_k_both), 0, 0, 1, 1}, + {&__pyx_n_s_boundconstraint, __pyx_k_boundconstraint, sizeof(__pyx_k_boundconstraint), 0, 0, 1, 1}, + {&__pyx_n_s_bounded, __pyx_k_bounded, sizeof(__pyx_k_bounded), 0, 0, 1, 1}, + {&__pyx_n_s_boundtypes, __pyx_k_boundtypes, sizeof(__pyx_k_boundtypes), 0, 0, 1, 1}, + {&__pyx_n_s_branchVar, __pyx_k_branchVar, sizeof(__pyx_k_branchVar), 0, 0, 1, 1}, + {&__pyx_n_s_branchVarVal, __pyx_k_branchVarVal, sizeof(__pyx_k_branchVarVal), 0, 0, 1, 1}, + {&__pyx_n_s_branchbounds, __pyx_k_branchbounds, sizeof(__pyx_k_branchbounds), 0, 0, 1, 1}, + {&__pyx_n_s_branchdir, __pyx_k_branchdir, sizeof(__pyx_k_branchdir), 0, 0, 1, 1}, + {&__pyx_n_s_branchexecext, __pyx_k_branchexecext, sizeof(__pyx_k_branchexecext), 0, 0, 1, 1}, + {&__pyx_kp_u_branchexecext_is_a_fundamental_c, __pyx_k_branchexecext_is_a_fundamental_c, sizeof(__pyx_k_branchexecext_is_a_fundamental_c), 0, 1, 0, 0}, + {&__pyx_n_s_branchexeclp, __pyx_k_branchexeclp, sizeof(__pyx_k_branchexeclp), 0, 0, 1, 1}, + {&__pyx_kp_u_branchexeclp_is_a_fundamental_ca, __pyx_k_branchexeclp_is_a_fundamental_ca, sizeof(__pyx_k_branchexeclp_is_a_fundamental_ca), 0, 1, 0, 0}, + {&__pyx_n_s_branchexecps, __pyx_k_branchexecps, sizeof(__pyx_k_branchexecps), 0, 0, 1, 1}, + {&__pyx_kp_u_branchexecps_is_a_fundamental_ca, __pyx_k_branchexecps_is_a_fundamental_ca, sizeof(__pyx_k_branchexecps_is_a_fundamental_ca), 0, 1, 0, 0}, + {&__pyx_n_s_branchexit, __pyx_k_branchexit, sizeof(__pyx_k_branchexit), 0, 0, 1, 1}, + {&__pyx_n_s_branchexitsol, __pyx_k_branchexitsol, sizeof(__pyx_k_branchexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_branchfree, __pyx_k_branchfree, sizeof(__pyx_k_branchfree), 0, 0, 1, 1}, + {&__pyx_n_s_branchinit, __pyx_k_branchinit, sizeof(__pyx_k_branchinit), 0, 0, 1, 1}, + {&__pyx_n_s_branchinitsol, __pyx_k_branchinitsol, sizeof(__pyx_k_branchinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_branchrule, __pyx_k_branchrule, sizeof(__pyx_k_branchrule), 0, 0, 1, 1}, + {&__pyx_n_s_branchvars, __pyx_k_branchvars, sizeof(__pyx_k_branchvars), 0, 0, 1, 1}, + {&__pyx_n_s_buildGenExprObj, __pyx_k_buildGenExprObj, sizeof(__pyx_k_buildGenExprObj), 0, 0, 1, 1}, + {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, + {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1}, + {&__pyx_n_s_c_beg, __pyx_k_c_beg, sizeof(__pyx_k_c_beg), 0, 0, 1, 1}, + {&__pyx_n_s_c_binds, __pyx_k_c_binds, sizeof(__pyx_k_c_binds), 0, 0, 1, 1}, + {&__pyx_n_s_c_coefs, __pyx_k_c_coefs, sizeof(__pyx_k_c_coefs), 0, 0, 1, 1}, + {&__pyx_n_s_c_col, __pyx_k_c_col, sizeof(__pyx_k_c_col), 0, 0, 1, 1}, + {&__pyx_n_s_c_dualsol, __pyx_k_c_dualsol, sizeof(__pyx_k_c_dualsol), 0, 0, 1, 1}, + {&__pyx_n_s_c_inds, __pyx_k_c_inds, sizeof(__pyx_k_c_inds), 0, 0, 1, 1}, + {&__pyx_n_s_c_lb, __pyx_k_c_lb, sizeof(__pyx_k_c_lb), 0, 0, 1, 1}, + {&__pyx_n_s_c_lbs, __pyx_k_c_lbs, sizeof(__pyx_k_c_lbs), 0, 0, 1, 1}, + {&__pyx_n_s_c_lhs, __pyx_k_c_lhs, sizeof(__pyx_k_c_lhs), 0, 0, 1, 1}, + {&__pyx_n_s_c_lhss, __pyx_k_c_lhss, sizeof(__pyx_k_c_lhss), 0, 0, 1, 1}, + {&__pyx_n_s_c_obj, __pyx_k_c_obj, sizeof(__pyx_k_c_obj), 0, 0, 1, 1}, + {&__pyx_n_s_c_objs, __pyx_k_c_objs, sizeof(__pyx_k_c_objs), 0, 0, 1, 1}, + {&__pyx_n_s_c_path, __pyx_k_c_path, sizeof(__pyx_k_c_path), 0, 0, 1, 1}, + {&__pyx_n_s_c_primalsol, __pyx_k_c_primalsol, sizeof(__pyx_k_c_primalsol), 0, 0, 1, 1}, + {&__pyx_n_s_c_ray, __pyx_k_c_ray, sizeof(__pyx_k_c_ray), 0, 0, 1, 1}, + {&__pyx_n_s_c_redcost, __pyx_k_c_redcost, sizeof(__pyx_k_c_redcost), 0, 0, 1, 1}, + {&__pyx_n_s_c_rhs, __pyx_k_c_rhs, sizeof(__pyx_k_c_rhs), 0, 0, 1, 1}, + {&__pyx_n_s_c_rhss, __pyx_k_c_rhss, sizeof(__pyx_k_c_rhss), 0, 0, 1, 1}, + {&__pyx_n_s_c_row, __pyx_k_c_row, sizeof(__pyx_k_c_row), 0, 0, 1, 1}, + {&__pyx_n_s_c_ub, __pyx_k_c_ub, sizeof(__pyx_k_c_ub), 0, 0, 1, 1}, + {&__pyx_n_s_c_ubs, __pyx_k_c_ubs, sizeof(__pyx_k_c_ubs), 0, 0, 1, 1}, + {&__pyx_n_s_cacheRowExtensions, __pyx_k_cacheRowExtensions, sizeof(__pyx_k_cacheRowExtensions), 0, 0, 1, 1}, + {&__pyx_n_s_calcChildEstimate, __pyx_k_calcChildEstimate, sizeof(__pyx_k_calcChildEstimate), 0, 0, 1, 1}, + {&__pyx_n_s_calcNodeselPriority, __pyx_k_calcNodeselPriority, sizeof(__pyx_k_calcNodeselPriority), 0, 0, 1, 1}, + {&__pyx_kp_u_can_only_be_called_with_a_valid, __pyx_k_can_only_be_called_with_a_valid, sizeof(__pyx_k_can_only_be_called_with_a_valid), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_BoundChange_with_S, __pyx_k_cannot_create_BoundChange_with_S, sizeof(__pyx_k_cannot_create_BoundChange_with_S), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_Column_with_SCIP_C, __pyx_k_cannot_create_Column_with_SCIP_C, sizeof(__pyx_k_cannot_create_Column_with_SCIP_C), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_Constraint_with_SC, __pyx_k_cannot_create_Constraint_with_SC, sizeof(__pyx_k_cannot_create_Constraint_with_SC), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_DomainChanges_with, __pyx_k_cannot_create_DomainChanges_with, sizeof(__pyx_k_cannot_create_DomainChanges_with), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_Event_with_SCIP_EV, __pyx_k_cannot_create_Event_with_SCIP_EV, sizeof(__pyx_k_cannot_create_Event_with_SCIP_EV), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_Model_with_SCIP_NU, __pyx_k_cannot_create_Model_with_SCIP_NU, sizeof(__pyx_k_cannot_create_Model_with_SCIP_NU), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_NLRow_with_SCIP_NL, __pyx_k_cannot_create_NLRow_with_SCIP_NL, sizeof(__pyx_k_cannot_create_NLRow_with_SCIP_NL), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_Row_with_SCIP_ROW, __pyx_k_cannot_create_Row_with_SCIP_ROW, sizeof(__pyx_k_cannot_create_Row_with_SCIP_ROW), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_Solution_with_SCIP, __pyx_k_cannot_create_Solution_with_SCIP, sizeof(__pyx_k_cannot_create_Solution_with_SCIP), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_create_Variable_with_SCIP, __pyx_k_cannot_create_Variable_with_SCIP, sizeof(__pyx_k_cannot_create_Variable_with_SCIP), 0, 1, 0, 0}, + {&__pyx_kp_u_cannot_divide_by_0, __pyx_k_cannot_divide_by_0, sizeof(__pyx_k_cannot_divide_by_0), 0, 1, 0, 0}, + {&__pyx_n_s_capsule, __pyx_k_capsule, sizeof(__pyx_k_capsule), 0, 0, 1, 1}, + {&__pyx_n_s_cardval, __pyx_k_cardval, sizeof(__pyx_k_cardval), 0, 0, 1, 1}, + {&__pyx_n_s_catchEvent, __pyx_k_catchEvent, sizeof(__pyx_k_catchEvent), 0, 0, 1, 1}, + {&__pyx_n_s_catchRowEvent, __pyx_k_catchRowEvent, sizeof(__pyx_k_catchRowEvent), 0, 0, 1, 1}, + {&__pyx_n_s_catchVarEvent, __pyx_k_catchVarEvent, sizeof(__pyx_k_catchVarEvent), 0, 0, 1, 1}, + {&__pyx_n_s_category, __pyx_k_category, sizeof(__pyx_k_category), 0, 0, 1, 1}, + {&__pyx_n_s_cfile, __pyx_k_cfile, sizeof(__pyx_k_cfile), 0, 0, 1, 1}, + {&__pyx_n_s_chckpriority, __pyx_k_chckpriority, sizeof(__pyx_k_chckpriority), 0, 0, 1, 1}, + {&__pyx_n_s_check, __pyx_k_check, sizeof(__pyx_k_check), 0, 0, 1, 1}, + {&__pyx_n_u_check, __pyx_k_check, sizeof(__pyx_k_check), 0, 1, 0, 1}, + {&__pyx_n_s_checkBendersSubproblemOptimality, __pyx_k_checkBendersSubproblemOptimality, sizeof(__pyx_k_checkBendersSubproblemOptimality), 0, 0, 1, 1}, + {&__pyx_n_s_checkQuadraticNonlinear, __pyx_k_checkQuadraticNonlinear, sizeof(__pyx_k_checkQuadraticNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_checkSol, __pyx_k_checkSol, sizeof(__pyx_k_checkSol), 0, 0, 1, 1}, + {&__pyx_n_s_checkStage, __pyx_k_checkStage, sizeof(__pyx_k_checkStage), 0, 0, 1, 1}, + {&__pyx_n_s_checkbounds, __pyx_k_checkbounds, sizeof(__pyx_k_checkbounds), 0, 0, 1, 1}, + {&__pyx_n_s_checkint, __pyx_k_checkint, sizeof(__pyx_k_checkint), 0, 0, 1, 1}, + {&__pyx_n_s_checkintegrality, __pyx_k_checkintegrality, sizeof(__pyx_k_checkintegrality), 0, 0, 1, 1}, + {&__pyx_n_s_checklprows, __pyx_k_checklprows, sizeof(__pyx_k_checklprows), 0, 0, 1, 1}, + {&__pyx_n_s_checktype, __pyx_k_checktype, sizeof(__pyx_k_checktype), 0, 0, 1, 1}, + {&__pyx_n_s_chgBound, __pyx_k_chgBound, sizeof(__pyx_k_chgBound), 0, 0, 1, 1}, + {&__pyx_n_s_chgCoef, __pyx_k_chgCoef, sizeof(__pyx_k_chgCoef), 0, 0, 1, 1}, + {&__pyx_n_s_chgCoefLinear, __pyx_k_chgCoefLinear, sizeof(__pyx_k_chgCoefLinear), 0, 0, 1, 1}, + {&__pyx_n_s_chgLhs, __pyx_k_chgLhs, sizeof(__pyx_k_chgLhs), 0, 0, 1, 1}, + {&__pyx_n_s_chgObj, __pyx_k_chgObj, sizeof(__pyx_k_chgObj), 0, 0, 1, 1}, + {&__pyx_n_s_chgReoptObjective, __pyx_k_chgReoptObjective, sizeof(__pyx_k_chgReoptObjective), 0, 0, 1, 1}, + {&__pyx_n_s_chgRhs, __pyx_k_chgRhs, sizeof(__pyx_k_chgRhs), 0, 0, 1, 1}, + {&__pyx_n_s_chgRowLhsDive, __pyx_k_chgRowLhsDive, sizeof(__pyx_k_chgRowLhsDive), 0, 0, 1, 1}, + {&__pyx_n_s_chgRowRhsDive, __pyx_k_chgRowRhsDive, sizeof(__pyx_k_chgRowRhsDive), 0, 0, 1, 1}, + {&__pyx_n_s_chgSide, __pyx_k_chgSide, sizeof(__pyx_k_chgSide), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarBranchPriority, __pyx_k_chgVarBranchPriority, sizeof(__pyx_k_chgVarBranchPriority), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarLb, __pyx_k_chgVarLb, sizeof(__pyx_k_chgVarLb), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarLbDive, __pyx_k_chgVarLbDive, sizeof(__pyx_k_chgVarLbDive), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarLbGlobal, __pyx_k_chgVarLbGlobal, sizeof(__pyx_k_chgVarLbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarLbNode, __pyx_k_chgVarLbNode, sizeof(__pyx_k_chgVarLbNode), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarLbProbing, __pyx_k_chgVarLbProbing, sizeof(__pyx_k_chgVarLbProbing), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarObjDive, __pyx_k_chgVarObjDive, sizeof(__pyx_k_chgVarObjDive), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarObjProbing, __pyx_k_chgVarObjProbing, sizeof(__pyx_k_chgVarObjProbing), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarType, __pyx_k_chgVarType, sizeof(__pyx_k_chgVarType), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarUb, __pyx_k_chgVarUb, sizeof(__pyx_k_chgVarUb), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarUbDive, __pyx_k_chgVarUbDive, sizeof(__pyx_k_chgVarUbDive), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarUbGlobal, __pyx_k_chgVarUbGlobal, sizeof(__pyx_k_chgVarUbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarUbNode, __pyx_k_chgVarUbNode, sizeof(__pyx_k_chgVarUbNode), 0, 0, 1, 1}, + {&__pyx_n_s_chgVarUbProbing, __pyx_k_chgVarUbProbing, sizeof(__pyx_k_chgVarUbProbing), 0, 0, 1, 1}, + {&__pyx_n_s_child, __pyx_k_child, sizeof(__pyx_k_child), 0, 0, 1, 1}, + {&__pyx_n_s_children, __pyx_k_children, sizeof(__pyx_k_children), 0, 0, 1, 1}, + {&__pyx_n_s_children_2, __pyx_k_children_2, sizeof(__pyx_k_children_2), 0, 0, 1, 1}, + {&__pyx_n_s_childrenexpr, __pyx_k_childrenexpr, sizeof(__pyx_k_childrenexpr), 0, 0, 1, 1}, + {&__pyx_n_s_chr, __pyx_k_chr, sizeof(__pyx_k_chr), 0, 0, 1, 1}, + {&__pyx_kp_u_cip, __pyx_k_cip, sizeof(__pyx_k_cip), 0, 1, 0, 0}, + {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, + {&__pyx_n_s_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 0, 1, 1}, + {&__pyx_n_s_clear, __pyx_k_clear, sizeof(__pyx_k_clear), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_closefd, __pyx_k_closefd, sizeof(__pyx_k_closefd), 0, 0, 1, 1}, + {&__pyx_n_s_cname, __pyx_k_cname, sizeof(__pyx_k_cname), 0, 0, 1, 1}, + {&__pyx_n_s_coef, __pyx_k_coef, sizeof(__pyx_k_coef), 0, 0, 1, 1}, + {&__pyx_n_s_coeff, __pyx_k_coeff, sizeof(__pyx_k_coeff), 0, 0, 1, 1}, + {&__pyx_kp_u_coefficients_not_available_for_c, __pyx_k_coefficients_not_available_for_c, sizeof(__pyx_k_coefficients_not_available_for_c), 0, 1, 0, 0}, + {&__pyx_n_s_coeffs, __pyx_k_coeffs, sizeof(__pyx_k_coeffs), 0, 0, 1, 1}, + {&__pyx_n_s_coeffs_2, __pyx_k_coeffs_2, sizeof(__pyx_k_coeffs_2), 0, 0, 1, 1}, + {&__pyx_n_s_coeffs_array, __pyx_k_coeffs_array, sizeof(__pyx_k_coeffs_array), 0, 0, 1, 1}, + {&__pyx_n_s_coefs, __pyx_k_coefs, sizeof(__pyx_k_coefs), 0, 0, 1, 1}, + {&__pyx_n_s_col, __pyx_k_col, sizeof(__pyx_k_col), 0, 0, 1, 1}, + {&__pyx_n_s_collections_abc, __pyx_k_collections_abc, sizeof(__pyx_k_collections_abc), 0, 0, 1, 1}, + {&__pyx_n_s_cols, __pyx_k_cols, sizeof(__pyx_k_cols), 0, 0, 1, 1}, + {&__pyx_n_s_comments, __pyx_k_comments, sizeof(__pyx_k_comments), 0, 0, 1, 1}, + {&__pyx_n_s_completely, __pyx_k_completely, sizeof(__pyx_k_completely), 0, 0, 1, 1}, + {&__pyx_n_s_computeBestSolSubproblems, __pyx_k_computeBestSolSubproblems, sizeof(__pyx_k_computeBestSolSubproblems), 0, 0, 1, 1}, + {&__pyx_n_s_confvar, __pyx_k_confvar, sizeof(__pyx_k_confvar), 0, 0, 1, 1}, + {&__pyx_n_s_cons, __pyx_k_cons, sizeof(__pyx_k_cons), 0, 0, 1, 1}, + {&__pyx_n_s_consactive, __pyx_k_consactive, sizeof(__pyx_k_consactive), 0, 0, 1, 1}, + {&__pyx_n_s_conscheck, __pyx_k_conscheck, sizeof(__pyx_k_conscheck), 0, 0, 1, 1}, + {&__pyx_n_s_conscopy, __pyx_k_conscopy, sizeof(__pyx_k_conscopy), 0, 0, 1, 1}, + {&__pyx_n_s_consdeactive, __pyx_k_consdeactive, sizeof(__pyx_k_consdeactive), 0, 0, 1, 1}, + {&__pyx_n_s_consdelete, __pyx_k_consdelete, sizeof(__pyx_k_consdelete), 0, 0, 1, 1}, + {&__pyx_n_s_consdelvars, __pyx_k_consdelvars, sizeof(__pyx_k_consdelvars), 0, 0, 1, 1}, + {&__pyx_n_s_consdisable, __pyx_k_consdisable, sizeof(__pyx_k_consdisable), 0, 0, 1, 1}, + {&__pyx_n_s_consenable, __pyx_k_consenable, sizeof(__pyx_k_consenable), 0, 0, 1, 1}, + {&__pyx_n_s_consenfolp, __pyx_k_consenfolp, sizeof(__pyx_k_consenfolp), 0, 0, 1, 1}, + {&__pyx_n_s_consenfops, __pyx_k_consenfops, sizeof(__pyx_k_consenfops), 0, 0, 1, 1}, + {&__pyx_n_s_consenforelax, __pyx_k_consenforelax, sizeof(__pyx_k_consenforelax), 0, 0, 1, 1}, + {&__pyx_n_s_consexit, __pyx_k_consexit, sizeof(__pyx_k_consexit), 0, 0, 1, 1}, + {&__pyx_n_s_consexitpre, __pyx_k_consexitpre, sizeof(__pyx_k_consexitpre), 0, 0, 1, 1}, + {&__pyx_n_s_consexitsol, __pyx_k_consexitsol, sizeof(__pyx_k_consexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_consfree, __pyx_k_consfree, sizeof(__pyx_k_consfree), 0, 0, 1, 1}, + {&__pyx_n_s_consgetdivebdchgs, __pyx_k_consgetdivebdchgs, sizeof(__pyx_k_consgetdivebdchgs), 0, 0, 1, 1}, + {&__pyx_n_s_consgetnvars, __pyx_k_consgetnvars, sizeof(__pyx_k_consgetnvars), 0, 0, 1, 1}, + {&__pyx_n_s_consgetpermsymgraph, __pyx_k_consgetpermsymgraph, sizeof(__pyx_k_consgetpermsymgraph), 0, 0, 1, 1}, + {&__pyx_n_s_consgetsignedpermsymgraph, __pyx_k_consgetsignedpermsymgraph, sizeof(__pyx_k_consgetsignedpermsymgraph), 0, 0, 1, 1}, + {&__pyx_n_s_consgetvars, __pyx_k_consgetvars, sizeof(__pyx_k_consgetvars), 0, 0, 1, 1}, + {&__pyx_n_s_conshdlr, __pyx_k_conshdlr, sizeof(__pyx_k_conshdlr), 0, 0, 1, 1}, + {&__pyx_n_s_conshdrlname, __pyx_k_conshdrlname, sizeof(__pyx_k_conshdrlname), 0, 0, 1, 1}, + {&__pyx_n_s_consinit, __pyx_k_consinit, sizeof(__pyx_k_consinit), 0, 0, 1, 1}, + {&__pyx_n_s_consinitlp, __pyx_k_consinitlp, sizeof(__pyx_k_consinitlp), 0, 0, 1, 1}, + {&__pyx_n_s_consinitpre, __pyx_k_consinitpre, sizeof(__pyx_k_consinitpre), 0, 0, 1, 1}, + {&__pyx_n_s_consinitsol, __pyx_k_consinitsol, sizeof(__pyx_k_consinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_conslock, __pyx_k_conslock, sizeof(__pyx_k_conslock), 0, 0, 1, 1}, + {&__pyx_n_s_consparse, __pyx_k_consparse, sizeof(__pyx_k_consparse), 0, 0, 1, 1}, + {&__pyx_n_s_conspresol, __pyx_k_conspresol, sizeof(__pyx_k_conspresol), 0, 0, 1, 1}, + {&__pyx_n_s_consprint, __pyx_k_consprint, sizeof(__pyx_k_consprint), 0, 0, 1, 1}, + {&__pyx_n_s_consprop, __pyx_k_consprop, sizeof(__pyx_k_consprop), 0, 0, 1, 1}, + {&__pyx_n_s_consresprop, __pyx_k_consresprop, sizeof(__pyx_k_consresprop), 0, 0, 1, 1}, + {&__pyx_n_s_conss, __pyx_k_conss, sizeof(__pyx_k_conss), 0, 0, 1, 1}, + {&__pyx_n_s_conss_2, __pyx_k_conss_2, sizeof(__pyx_k_conss_2), 0, 0, 1, 1}, + {&__pyx_n_s_conssepalp, __pyx_k_conssepalp, sizeof(__pyx_k_conssepalp), 0, 0, 1, 1}, + {&__pyx_n_s_conssepasol, __pyx_k_conssepasol, sizeof(__pyx_k_conssepasol), 0, 0, 1, 1}, + {&__pyx_n_s_const, __pyx_k_const, sizeof(__pyx_k_const), 0, 0, 1, 1}, + {&__pyx_n_u_const, __pyx_k_const, sizeof(__pyx_k_const), 0, 1, 0, 1}, + {&__pyx_n_s_constant, __pyx_k_constant, sizeof(__pyx_k_constant), 0, 0, 1, 1}, + {&__pyx_n_s_constraint, __pyx_k_constraint, sizeof(__pyx_k_constraint), 0, 0, 1, 1}, + {&__pyx_kp_u_constraint_is_not_nonlinear, __pyx_k_constraint_is_not_nonlinear, sizeof(__pyx_k_constraint_is_not_nonlinear), 0, 1, 0, 0}, + {&__pyx_kp_u_constraint_is_not_quadratic, __pyx_k_constraint_is_not_quadratic, sizeof(__pyx_k_constraint_is_not_quadratic), 0, 1, 0, 0}, + {&__pyx_n_s_constraints, __pyx_k_constraints, sizeof(__pyx_k_constraints), 0, 0, 1, 1}, + {&__pyx_kp_u_constraints_benders_active, __pyx_k_constraints_benders_active, sizeof(__pyx_k_constraints_benders_active), 0, 1, 0, 0}, + {&__pyx_kp_u_constraints_benderslp_active, __pyx_k_constraints_benderslp_active, sizeof(__pyx_k_constraints_benderslp_active), 0, 1, 0, 0}, + {&__pyx_n_s_constrans, __pyx_k_constrans, sizeof(__pyx_k_constrans), 0, 0, 1, 1}, + {&__pyx_n_s_constructLP, __pyx_k_constructLP, sizeof(__pyx_k_constructLP), 0, 0, 1, 1}, + {&__pyx_n_s_constype, __pyx_k_constype, sizeof(__pyx_k_constype), 0, 0, 1, 1}, + {&__pyx_n_s_consvars, __pyx_k_consvars, sizeof(__pyx_k_consvars), 0, 0, 1, 1}, + {&__pyx_n_s_contvars, __pyx_k_contvars, sizeof(__pyx_k_contvars), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_cos, __pyx_k_cos, sizeof(__pyx_k_cos), 0, 0, 1, 1}, + {&__pyx_n_u_cos, __pyx_k_cos, sizeof(__pyx_k_cos), 0, 1, 0, 1}, + {&__pyx_kp_u_could_not_change_variable_type_o, __pyx_k_could_not_change_variable_type_o, sizeof(__pyx_k_could_not_change_variable_type_o), 0, 1, 0, 0}, + {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, + {&__pyx_n_s_createChild, __pyx_k_createChild, sizeof(__pyx_k_createChild), 0, 0, 1, 1}, + {&__pyx_n_s_createCons, __pyx_k_createCons, sizeof(__pyx_k_createCons), 0, 0, 1, 1}, + {&__pyx_n_s_createConsFromExpr, __pyx_k_createConsFromExpr, sizeof(__pyx_k_createConsFromExpr), 0, 0, 1, 1}, + {&__pyx_n_s_createConsGenNonlinear, __pyx_k_createConsGenNonlinear, sizeof(__pyx_k_createConsGenNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_createConsLinear, __pyx_k_createConsLinear, sizeof(__pyx_k_createConsLinear), 0, 0, 1, 1}, + {&__pyx_n_s_createConsNonlinear, __pyx_k_createConsNonlinear, sizeof(__pyx_k_createConsNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_createConsQuadratic, __pyx_k_createConsQuadratic, sizeof(__pyx_k_createConsQuadratic), 0, 0, 1, 1}, + {&__pyx_n_s_createEmptyRowSepa, __pyx_k_createEmptyRowSepa, sizeof(__pyx_k_createEmptyRowSepa), 0, 0, 1, 1}, + {&__pyx_n_s_createEmptyRowUnspec, __pyx_k_createEmptyRowUnspec, sizeof(__pyx_k_createEmptyRowUnspec), 0, 0, 1, 1}, + {&__pyx_n_s_createOrigSol, __pyx_k_createOrigSol, sizeof(__pyx_k_createOrigSol), 0, 0, 1, 1}, + {&__pyx_n_s_createPartialSol, __pyx_k_createPartialSol, sizeof(__pyx_k_createPartialSol), 0, 0, 1, 1}, + {&__pyx_n_s_createProbBasic, __pyx_k_createProbBasic, sizeof(__pyx_k_createProbBasic), 0, 0, 1, 1}, + {&__pyx_n_s_createSol, __pyx_k_createSol, sizeof(__pyx_k_createSol), 0, 0, 1, 1}, + {&__pyx_n_s_createscip, __pyx_k_createscip, sizeof(__pyx_k_createscip), 0, 0, 1, 1}, + {&__pyx_n_s_cut, __pyx_k_cut, sizeof(__pyx_k_cut), 0, 0, 1, 1}, + {&__pyx_n_s_cutlp, __pyx_k_cutlp, sizeof(__pyx_k_cutlp), 0, 0, 1, 1}, + {&__pyx_n_s_cutoff, __pyx_k_cutoff, sizeof(__pyx_k_cutoff), 0, 0, 1, 1}, + {&__pyx_n_s_cutpseudo, __pyx_k_cutpseudo, sizeof(__pyx_k_cutpseudo), 0, 0, 1, 1}, + {&__pyx_n_s_cutrelax, __pyx_k_cutrelax, sizeof(__pyx_k_cutrelax), 0, 0, 1, 1}, + {&__pyx_n_s_cuts, __pyx_k_cuts, sizeof(__pyx_k_cuts), 0, 0, 1, 1}, + {&__pyx_n_u_cuts, __pyx_k_cuts, sizeof(__pyx_k_cuts), 0, 1, 0, 1}, + {&__pyx_n_s_cutsel, __pyx_k_cutsel, sizeof(__pyx_k_cutsel), 0, 0, 1, 1}, + {&__pyx_n_s_cutselexit, __pyx_k_cutselexit, sizeof(__pyx_k_cutselexit), 0, 0, 1, 1}, + {&__pyx_n_s_cutselexitsol, __pyx_k_cutselexitsol, sizeof(__pyx_k_cutselexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_cutselfree, __pyx_k_cutselfree, sizeof(__pyx_k_cutselfree), 0, 0, 1, 1}, + {&__pyx_n_s_cutselinit, __pyx_k_cutselinit, sizeof(__pyx_k_cutselinit), 0, 0, 1, 1}, + {&__pyx_n_s_cutselinitsol, __pyx_k_cutselinitsol, sizeof(__pyx_k_cutselinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_cutselselect, __pyx_k_cutselselect, sizeof(__pyx_k_cutselselect), 0, 0, 1, 1}, + {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1}, + {&__pyx_n_s_defaultPlugins, __pyx_k_defaultPlugins, sizeof(__pyx_k_defaultPlugins), 0, 0, 1, 1}, + {&__pyx_n_s_deg, __pyx_k_deg, sizeof(__pyx_k_deg), 0, 0, 1, 1}, + {&__pyx_n_s_degree, __pyx_k_degree, sizeof(__pyx_k_degree), 0, 0, 1, 1}, + {&__pyx_n_s_degree_locals_genexpr, __pyx_k_degree_locals_genexpr, sizeof(__pyx_k_degree_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_delCoefLinear, __pyx_k_delCoefLinear, sizeof(__pyx_k_delCoefLinear), 0, 0, 1, 1}, + {&__pyx_n_s_delCols, __pyx_k_delCols, sizeof(__pyx_k_delCols), 0, 0, 1, 1}, + {&__pyx_n_s_delCons, __pyx_k_delCons, sizeof(__pyx_k_delCons), 0, 0, 1, 1}, + {&__pyx_n_s_delConsLocal, __pyx_k_delConsLocal, sizeof(__pyx_k_delConsLocal), 0, 0, 1, 1}, + {&__pyx_n_s_delRows, __pyx_k_delRows, sizeof(__pyx_k_delRows), 0, 0, 1, 1}, + {&__pyx_n_s_delVar, __pyx_k_delVar, sizeof(__pyx_k_delVar), 0, 0, 1, 1}, + {&__pyx_n_s_delay, __pyx_k_delay, sizeof(__pyx_k_delay), 0, 0, 1, 1}, + {&__pyx_n_s_delayed, __pyx_k_delayed, sizeof(__pyx_k_delayed), 0, 0, 1, 1}, + {&__pyx_n_s_delayprop, __pyx_k_delayprop, sizeof(__pyx_k_delayprop), 0, 0, 1, 1}, + {&__pyx_n_s_delaysepa, __pyx_k_delaysepa, sizeof(__pyx_k_delaysepa), 0, 0, 1, 1}, + {&__pyx_n_s_deleted, __pyx_k_deleted, sizeof(__pyx_k_deleted), 0, 0, 1, 1}, + {&__pyx_n_s_des, __pyx_k_des, sizeof(__pyx_k_des), 0, 0, 1, 1}, + {&__pyx_n_s_desc, __pyx_k_desc, sizeof(__pyx_k_desc), 0, 0, 1, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dict_2, __pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 0, 1, 1}, + {&__pyx_n_s_dis, __pyx_k_dis, sizeof(__pyx_k_dis), 0, 0, 1, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_n_s_disablePropagation, __pyx_k_disablePropagation, sizeof(__pyx_k_disablePropagation), 0, 0, 1, 1}, + {&__pyx_n_s_disj_cons, __pyx_k_disj_cons, sizeof(__pyx_k_disj_cons), 0, 0, 1, 1}, + {&__pyx_n_s_dispchar, __pyx_k_dispchar, sizeof(__pyx_k_dispchar), 0, 0, 1, 1}, + {&__pyx_n_s_div, __pyx_k_div, sizeof(__pyx_k_div), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_domchg, __pyx_k_domchg, sizeof(__pyx_k_domchg), 0, 0, 1, 1}, + {&__pyx_n_s_downchild, __pyx_k_downchild, sizeof(__pyx_k_downchild), 0, 0, 1, 1}, + {&__pyx_n_s_dropEvent, __pyx_k_dropEvent, sizeof(__pyx_k_dropEvent), 0, 0, 1, 1}, + {&__pyx_n_s_dropRowEvent, __pyx_k_dropRowEvent, sizeof(__pyx_k_dropRowEvent), 0, 0, 1, 1}, + {&__pyx_n_s_dropVarEvent, __pyx_k_dropVarEvent, sizeof(__pyx_k_dropVarEvent), 0, 0, 1, 1}, + {&__pyx_n_s_dual, __pyx_k_dual, sizeof(__pyx_k_dual), 0, 0, 1, 1}, + {&__pyx_kp_u_dual_solution_values_not_availab, __pyx_k_dual_solution_values_not_availab, sizeof(__pyx_k_dual_solution_values_not_availab), 0, 1, 0, 0}, + {&__pyx_n_u_duallimit, __pyx_k_duallimit, sizeof(__pyx_k_duallimit), 0, 1, 0, 1}, + {&__pyx_n_s_dualsol, __pyx_k_dualsol, sizeof(__pyx_k_dualsol), 0, 0, 1, 1}, + {&__pyx_n_s_dualsol_2, __pyx_k_dualsol_2, sizeof(__pyx_k_dualsol_2), 0, 0, 1, 1}, + {&__pyx_n_s_dummy_boundtypes, __pyx_k_dummy_boundtypes, sizeof(__pyx_k_dummy_boundtypes), 0, 0, 1, 1}, + {&__pyx_n_s_dummy_branchbounds, __pyx_k_dummy_branchbounds, sizeof(__pyx_k_dummy_branchbounds), 0, 0, 1, 1}, + {&__pyx_n_s_dummy_branchvars, __pyx_k_dummy_branchvars, sizeof(__pyx_k_dummy_branchvars), 0, 0, 1, 1}, + {&__pyx_n_s_dynamic, __pyx_k_dynamic, sizeof(__pyx_k_dynamic), 0, 0, 1, 1}, + {&__pyx_n_u_dynamic, __pyx_k_dynamic, sizeof(__pyx_k_dynamic), 0, 1, 0, 1}, + {&__pyx_n_s_e, __pyx_k_e, sizeof(__pyx_k_e), 0, 0, 1, 1}, + {&__pyx_n_s_eagerfreq, __pyx_k_eagerfreq, sizeof(__pyx_k_eagerfreq), 0, 0, 1, 1}, + {&__pyx_n_s_elem, __pyx_k_elem, sizeof(__pyx_k_elem), 0, 0, 1, 1}, + {&__pyx_n_s_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 0, 1, 1}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_s_enableReoptimization, __pyx_k_enableReoptimization, sizeof(__pyx_k_enableReoptimization), 0, 0, 1, 1}, + {&__pyx_n_s_enablepricing, __pyx_k_enablepricing, sizeof(__pyx_k_enablepricing), 0, 0, 1, 1}, + {&__pyx_n_s_endDive, __pyx_k_endDive, sizeof(__pyx_k_endDive), 0, 0, 1, 1}, + {&__pyx_n_s_endProbing, __pyx_k_endProbing, sizeof(__pyx_k_endProbing), 0, 0, 1, 1}, + {&__pyx_n_s_enfopriority, __pyx_k_enfopriority, sizeof(__pyx_k_enfopriority), 0, 0, 1, 1}, + {&__pyx_n_s_enforce, __pyx_k_enforce, sizeof(__pyx_k_enforce), 0, 0, 1, 1}, + {&__pyx_n_u_enforce, __pyx_k_enforce, sizeof(__pyx_k_enforce), 0, 1, 0, 1}, + {&__pyx_n_s_enfotype, __pyx_k_enfotype, sizeof(__pyx_k_enfotype), 0, 0, 1, 1}, + {&__pyx_n_s_ensure_iterable, __pyx_k_ensure_iterable, sizeof(__pyx_k_ensure_iterable), 0, 0, 1, 1}, + {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1}, + {&__pyx_n_s_entries, __pyx_k_entries, sizeof(__pyx_k_entries), 0, 0, 1, 1}, + {&__pyx_n_s_entrieslist, __pyx_k_entrieslist, sizeof(__pyx_k_entrieslist), 0, 0, 1, 1}, + {&__pyx_n_s_entry, __pyx_k_entry, sizeof(__pyx_k_entry), 0, 0, 1, 1}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_n_s_epsilon, __pyx_k_epsilon, sizeof(__pyx_k_epsilon), 0, 0, 1, 1}, + {&__pyx_n_s_eq, __pyx_k_eq, sizeof(__pyx_k_eq), 0, 0, 1, 1}, + {&__pyx_n_s_eqchild, __pyx_k_eqchild, sizeof(__pyx_k_eqchild), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_estimate, __pyx_k_estimate, sizeof(__pyx_k_estimate), 0, 0, 1, 1}, + {&__pyx_n_s_evaluate, __pyx_k_evaluate, sizeof(__pyx_k_evaluate), 0, 0, 1, 1}, + {&__pyx_n_s_event, __pyx_k_event, sizeof(__pyx_k_event), 0, 0, 1, 1}, + {&__pyx_kp_u_event_handler_not_found, __pyx_k_event_handler_not_found, sizeof(__pyx_k_event_handler_not_found), 0, 1, 0, 0}, + {&__pyx_n_s_eventcopy, __pyx_k_eventcopy, sizeof(__pyx_k_eventcopy), 0, 0, 1, 1}, + {&__pyx_n_s_eventdelete, __pyx_k_eventdelete, sizeof(__pyx_k_eventdelete), 0, 0, 1, 1}, + {&__pyx_n_s_eventexec, __pyx_k_eventexec, sizeof(__pyx_k_eventexec), 0, 0, 1, 1}, + {&__pyx_n_s_eventexit, __pyx_k_eventexit, sizeof(__pyx_k_eventexit), 0, 0, 1, 1}, + {&__pyx_n_s_eventexitsol, __pyx_k_eventexitsol, sizeof(__pyx_k_eventexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_eventfree, __pyx_k_eventfree, sizeof(__pyx_k_eventfree), 0, 0, 1, 1}, + {&__pyx_n_s_eventhdlr, __pyx_k_eventhdlr, sizeof(__pyx_k_eventhdlr), 0, 0, 1, 1}, + {&__pyx_n_s_eventhdlr_2, __pyx_k_eventhdlr_2, sizeof(__pyx_k_eventhdlr_2), 0, 0, 1, 1}, + {&__pyx_n_s_eventinit, __pyx_k_eventinit, sizeof(__pyx_k_eventinit), 0, 0, 1, 1}, + {&__pyx_n_s_eventinitsol, __pyx_k_eventinitsol, sizeof(__pyx_k_eventinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_eventtype, __pyx_k_eventtype, sizeof(__pyx_k_eventtype), 0, 0, 1, 1}, + {&__pyx_n_s_exact, __pyx_k_exact, sizeof(__pyx_k_exact), 0, 0, 1, 1}, + {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, + {&__pyx_n_s_exp, __pyx_k_exp, sizeof(__pyx_k_exp), 0, 0, 1, 1}, + {&__pyx_n_u_exp, __pyx_k_exp, sizeof(__pyx_k_exp), 0, 1, 0, 1}, + {&__pyx_kp_u_expected_inequality_that_has_eit, __pyx_k_expected_inequality_that_has_eit, sizeof(__pyx_k_expected_inequality_that_has_eit), 0, 1, 0, 0}, + {&__pyx_kp_u_expected_linear_inequality_expre, __pyx_k_expected_linear_inequality_expre, sizeof(__pyx_k_expected_linear_inequality_expre), 0, 1, 0, 0}, + {&__pyx_n_s_expo, __pyx_k_expo, sizeof(__pyx_k_expo), 0, 0, 1, 1}, + {&__pyx_n_s_exponent, __pyx_k_exponent, sizeof(__pyx_k_exponent), 0, 0, 1, 1}, + {&__pyx_kp_u_exponents_must_be_numbers, __pyx_k_exponents_must_be_numbers, sizeof(__pyx_k_exponents_must_be_numbers), 0, 1, 0, 0}, + {&__pyx_n_s_expr, __pyx_k_expr, sizeof(__pyx_k_expr), 0, 0, 1, 1}, + {&__pyx_n_s_expr_richcmp, __pyx_k_expr_richcmp, sizeof(__pyx_k_expr_richcmp), 0, 0, 1, 1}, + {&__pyx_n_s_expr_to_array, __pyx_k_expr_to_array, sizeof(__pyx_k_expr_to_array), 0, 0, 1, 1}, + {&__pyx_n_s_expr_to_nodes, __pyx_k_expr_to_nodes, sizeof(__pyx_k_expr_to_nodes), 0, 0, 1, 1}, + {&__pyx_n_s_ext, __pyx_k_ext, sizeof(__pyx_k_ext), 0, 0, 1, 1}, + {&__pyx_n_s_extend, __pyx_k_extend, sizeof(__pyx_k_extend), 0, 0, 1, 1}, + {&__pyx_n_s_extension, __pyx_k_extension, sizeof(__pyx_k_extension), 0, 0, 1, 1}, + {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1}, + {&__pyx_n_s_fabs, __pyx_k_fabs, sizeof(__pyx_k_fabs), 0, 0, 1, 1}, + {&__pyx_kp_u_failed, __pyx_k_failed, sizeof(__pyx_k_failed), 0, 1, 0, 0}, + {&__pyx_n_s_fdopen, __pyx_k_fdopen, sizeof(__pyx_k_fdopen), 0, 0, 1, 1}, + {&__pyx_n_s_feasFrac, __pyx_k_feasFrac, sizeof(__pyx_k_feasFrac), 0, 0, 1, 1}, + {&__pyx_n_s_feasibility, __pyx_k_feasibility, sizeof(__pyx_k_feasibility), 0, 0, 1, 1}, + {&__pyx_n_s_feasible, __pyx_k_feasible, sizeof(__pyx_k_feasible), 0, 0, 1, 1}, + {&__pyx_n_s_feastol, __pyx_k_feastol, sizeof(__pyx_k_feastol), 0, 0, 1, 1}, + {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1}, + {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1}, + {&__pyx_n_s_fileno, __pyx_k_fileno, sizeof(__pyx_k_fileno), 0, 0, 1, 1}, + {&__pyx_n_s_firstcol, __pyx_k_firstcol, sizeof(__pyx_k_firstcol), 0, 0, 1, 1}, + {&__pyx_n_s_firstrow, __pyx_k_firstrow, sizeof(__pyx_k_firstrow), 0, 0, 1, 1}, + {&__pyx_n_s_fixVar, __pyx_k_fixVar, sizeof(__pyx_k_fixVar), 0, 0, 1, 1}, + {&__pyx_n_s_fixVarProbing, __pyx_k_fixVarProbing, sizeof(__pyx_k_fixVarProbing), 0, 0, 1, 1}, + {&__pyx_n_s_fixed, __pyx_k_fixed, sizeof(__pyx_k_fixed), 0, 0, 1, 1}, + {&__pyx_n_s_fixedval, __pyx_k_fixedval, sizeof(__pyx_k_fixedval), 0, 0, 1, 1}, + {&__pyx_n_s_fixedvars, __pyx_k_fixedvars, sizeof(__pyx_k_fixedvars), 0, 0, 1, 1}, + {&__pyx_n_s_flushRowExtensions, __pyx_k_flushRowExtensions, sizeof(__pyx_k_flushRowExtensions), 0, 0, 1, 1}, + {&__pyx_n_s_fn, __pyx_k_fn, sizeof(__pyx_k_fn), 0, 0, 1, 1}, + {&__pyx_n_s_force, __pyx_k_force, sizeof(__pyx_k_force), 0, 0, 1, 1}, + {&__pyx_n_s_forcecut, __pyx_k_forcecut, sizeof(__pyx_k_forcecut), 0, 0, 1, 1}, + {&__pyx_n_s_forcedcuts, __pyx_k_forcedcuts, sizeof(__pyx_k_forcedcuts), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_frac, __pyx_k_frac, sizeof(__pyx_k_frac), 0, 0, 1, 1}, + {&__pyx_n_s_free, __pyx_k_free, sizeof(__pyx_k_free), 0, 0, 1, 1}, + {&__pyx_n_s_freeBendersSubproblems, __pyx_k_freeBendersSubproblems, sizeof(__pyx_k_freeBendersSubproblems), 0, 0, 1, 1}, + {&__pyx_n_s_freeProb, __pyx_k_freeProb, sizeof(__pyx_k_freeProb), 0, 0, 1, 1}, + {&__pyx_n_s_freeReoptSolve, __pyx_k_freeReoptSolve, sizeof(__pyx_k_freeReoptSolve), 0, 0, 1, 1}, + {&__pyx_n_s_freeSol, __pyx_k_freeSol, sizeof(__pyx_k_freeSol), 0, 0, 1, 1}, + {&__pyx_n_s_freeTransform, __pyx_k_freeTransform, sizeof(__pyx_k_freeTransform), 0, 0, 1, 1}, + {&__pyx_n_s_freescip, __pyx_k_freescip, sizeof(__pyx_k_freescip), 0, 0, 1, 1}, + {&__pyx_n_s_freq, __pyx_k_freq, sizeof(__pyx_k_freq), 0, 0, 1, 1}, + {&__pyx_n_s_freqofs, __pyx_k_freqofs, sizeof(__pyx_k_freqofs), 0, 0, 1, 1}, + {&__pyx_n_s_from_ptr, __pyx_k_from_ptr, sizeof(__pyx_k_from_ptr), 0, 0, 1, 1}, + {&__pyx_n_u_gaplimit, __pyx_k_gaplimit, sizeof(__pyx_k_gaplimit), 0, 1, 0, 1}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_genericnames, __pyx_k_genericnames, sizeof(__pyx_k_genericnames), 0, 0, 1, 1}, + {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_getActivity, __pyx_k_getActivity, sizeof(__pyx_k_getActivity), 0, 0, 1, 1}, + {&__pyx_n_s_getAddedConss, __pyx_k_getAddedConss, sizeof(__pyx_k_getAddedConss), 0, 0, 1, 1}, + {&__pyx_n_s_getBasisInds, __pyx_k_getBasisInds, sizeof(__pyx_k_getBasisInds), 0, 0, 1, 1}, + {&__pyx_n_s_getBasisStatus, __pyx_k_getBasisStatus, sizeof(__pyx_k_getBasisStatus), 0, 0, 1, 1}, + {&__pyx_n_s_getBendersAuxiliaryVar, __pyx_k_getBendersAuxiliaryVar, sizeof(__pyx_k_getBendersAuxiliaryVar), 0, 0, 1, 1}, + {&__pyx_n_s_getBendersSubproblem, __pyx_k_getBendersSubproblem, sizeof(__pyx_k_getBendersSubproblem), 0, 0, 1, 1}, + {&__pyx_n_s_getBendersVar, __pyx_k_getBendersVar, sizeof(__pyx_k_getBendersVar), 0, 0, 1, 1}, + {&__pyx_n_s_getBestChild, __pyx_k_getBestChild, sizeof(__pyx_k_getBestChild), 0, 0, 1, 1}, + {&__pyx_n_s_getBestLeaf, __pyx_k_getBestLeaf, sizeof(__pyx_k_getBestLeaf), 0, 0, 1, 1}, + {&__pyx_n_s_getBestNode, __pyx_k_getBestNode, sizeof(__pyx_k_getBestNode), 0, 0, 1, 1}, + {&__pyx_n_s_getBestSibling, __pyx_k_getBestSibling, sizeof(__pyx_k_getBestSibling), 0, 0, 1, 1}, + {&__pyx_n_s_getBestSol, __pyx_k_getBestSol, sizeof(__pyx_k_getBestSol), 0, 0, 1, 1}, + {&__pyx_n_s_getBestboundNode, __pyx_k_getBestboundNode, sizeof(__pyx_k_getBestboundNode), 0, 0, 1, 1}, + {&__pyx_n_s_getBoundchgs, __pyx_k_getBoundchgs, sizeof(__pyx_k_getBoundchgs), 0, 0, 1, 1}, + {&__pyx_n_s_getBoundchgtype, __pyx_k_getBoundchgtype, sizeof(__pyx_k_getBoundchgtype), 0, 0, 1, 1}, + {&__pyx_n_s_getBounds, __pyx_k_getBounds, sizeof(__pyx_k_getBounds), 0, 0, 1, 1}, + {&__pyx_n_s_getBoundtype, __pyx_k_getBoundtype, sizeof(__pyx_k_getBoundtype), 0, 0, 1, 1}, + {&__pyx_n_s_getCol, __pyx_k_getCol, sizeof(__pyx_k_getCol), 0, 0, 1, 1}, + {&__pyx_n_s_getCols, __pyx_k_getCols, sizeof(__pyx_k_getCols), 0, 0, 1, 1}, + {&__pyx_n_s_getCondition, __pyx_k_getCondition, sizeof(__pyx_k_getCondition), 0, 0, 1, 1}, + {&__pyx_n_s_getConsNVars, __pyx_k_getConsNVars, sizeof(__pyx_k_getConsNVars), 0, 0, 1, 1}, + {&__pyx_n_s_getConsOriginConshdlrtype, __pyx_k_getConsOriginConshdlrtype, sizeof(__pyx_k_getConsOriginConshdlrtype), 0, 0, 1, 1}, + {&__pyx_n_s_getConsVars, __pyx_k_getConsVars, sizeof(__pyx_k_getConsVars), 0, 0, 1, 1}, + {&__pyx_n_s_getConshdlrName, __pyx_k_getConshdlrName, sizeof(__pyx_k_getConshdlrName), 0, 0, 1, 1}, + {&__pyx_n_s_getConss, __pyx_k_getConss, sizeof(__pyx_k_getConss), 0, 0, 1, 1}, + {&__pyx_n_s_getConstant, __pyx_k_getConstant, sizeof(__pyx_k_getConstant), 0, 0, 1, 1}, + {&__pyx_n_s_getCurrentNode, __pyx_k_getCurrentNode, sizeof(__pyx_k_getCurrentNode), 0, 0, 1, 1}, + {&__pyx_n_s_getCutEfficacy, __pyx_k_getCutEfficacy, sizeof(__pyx_k_getCutEfficacy), 0, 0, 1, 1}, + {&__pyx_n_s_getCutLPSolCutoffDistance, __pyx_k_getCutLPSolCutoffDistance, sizeof(__pyx_k_getCutLPSolCutoffDistance), 0, 0, 1, 1}, + {&__pyx_n_s_getDepth, __pyx_k_getDepth, sizeof(__pyx_k_getDepth), 0, 0, 1, 1}, + {&__pyx_n_s_getDomchg, __pyx_k_getDomchg, sizeof(__pyx_k_getDomchg), 0, 0, 1, 1}, + {&__pyx_n_s_getDual, __pyx_k_getDual, sizeof(__pyx_k_getDual), 0, 0, 1, 1}, + {&__pyx_n_s_getDualMultiplier, __pyx_k_getDualMultiplier, sizeof(__pyx_k_getDualMultiplier), 0, 0, 1, 1}, + {&__pyx_n_s_getDualRay, __pyx_k_getDualRay, sizeof(__pyx_k_getDualRay), 0, 0, 1, 1}, + {&__pyx_n_s_getDualSolVal, __pyx_k_getDualSolVal, sizeof(__pyx_k_getDualSolVal), 0, 0, 1, 1}, + {&__pyx_n_s_getDualbound, __pyx_k_getDualbound, sizeof(__pyx_k_getDualbound), 0, 0, 1, 1}, + {&__pyx_n_s_getDualboundRoot, __pyx_k_getDualboundRoot, sizeof(__pyx_k_getDualboundRoot), 0, 0, 1, 1}, + {&__pyx_n_s_getDualfarkasLinear, __pyx_k_getDualfarkasLinear, sizeof(__pyx_k_getDualfarkasLinear), 0, 0, 1, 1}, + {&__pyx_n_s_getDualsol, __pyx_k_getDualsol, sizeof(__pyx_k_getDualsol), 0, 0, 1, 1}, + {&__pyx_n_s_getDualsolLinear, __pyx_k_getDualsolLinear, sizeof(__pyx_k_getDualsolLinear), 0, 0, 1, 1}, + {&__pyx_n_s_getEstimate, __pyx_k_getEstimate, sizeof(__pyx_k_getEstimate), 0, 0, 1, 1}, + {&__pyx_n_s_getEventNames, __pyx_k_getEventNames, sizeof(__pyx_k_getEventNames), 0, 0, 1, 1}, + {&__pyx_n_s_getGap, __pyx_k_getGap, sizeof(__pyx_k_getGap), 0, 0, 1, 1}, + {&__pyx_n_s_getIndex, __pyx_k_getIndex, sizeof(__pyx_k_getIndex), 0, 0, 1, 1}, + {&__pyx_n_s_getLPBInvARow, __pyx_k_getLPBInvARow, sizeof(__pyx_k_getLPBInvARow), 0, 0, 1, 1}, + {&__pyx_n_s_getLPBInvRow, __pyx_k_getLPBInvRow, sizeof(__pyx_k_getLPBInvRow), 0, 0, 1, 1}, + {&__pyx_n_s_getLPBasisInd, __pyx_k_getLPBasisInd, sizeof(__pyx_k_getLPBasisInd), 0, 0, 1, 1}, + {&__pyx_n_s_getLPBranchCands, __pyx_k_getLPBranchCands, sizeof(__pyx_k_getLPBranchCands), 0, 0, 1, 1}, + {&__pyx_n_s_getLPColsData, __pyx_k_getLPColsData, sizeof(__pyx_k_getLPColsData), 0, 0, 1, 1}, + {&__pyx_n_s_getLPObjVal, __pyx_k_getLPObjVal, sizeof(__pyx_k_getLPObjVal), 0, 0, 1, 1}, + {&__pyx_n_s_getLPPos, __pyx_k_getLPPos, sizeof(__pyx_k_getLPPos), 0, 0, 1, 1}, + {&__pyx_n_s_getLPRowsData, __pyx_k_getLPRowsData, sizeof(__pyx_k_getLPRowsData), 0, 0, 1, 1}, + {&__pyx_n_s_getLPSol, __pyx_k_getLPSol, sizeof(__pyx_k_getLPSol), 0, 0, 1, 1}, + {&__pyx_n_s_getLPSolstat, __pyx_k_getLPSolstat, sizeof(__pyx_k_getLPSolstat), 0, 0, 1, 1}, + {&__pyx_n_s_getLb, __pyx_k_getLb, sizeof(__pyx_k_getLb), 0, 0, 1, 1}, + {&__pyx_n_s_getLbGlobal, __pyx_k_getLbGlobal, sizeof(__pyx_k_getLbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_getLbLocal, __pyx_k_getLbLocal, sizeof(__pyx_k_getLbLocal), 0, 0, 1, 1}, + {&__pyx_n_s_getLbOriginal, __pyx_k_getLbOriginal, sizeof(__pyx_k_getLbOriginal), 0, 0, 1, 1}, + {&__pyx_n_s_getLhs, __pyx_k_getLhs, sizeof(__pyx_k_getLhs), 0, 0, 1, 1}, + {&__pyx_n_s_getLinearTerms, __pyx_k_getLinearTerms, sizeof(__pyx_k_getLinearTerms), 0, 0, 1, 1}, + {&__pyx_n_s_getLocalEstimate, __pyx_k_getLocalEstimate, sizeof(__pyx_k_getLocalEstimate), 0, 0, 1, 1}, + {&__pyx_n_s_getLowerbound, __pyx_k_getLowerbound, sizeof(__pyx_k_getLowerbound), 0, 0, 1, 1}, + {&__pyx_n_s_getNAddedConss, __pyx_k_getNAddedConss, sizeof(__pyx_k_getNAddedConss), 0, 0, 1, 1}, + {&__pyx_n_s_getNBestSolsFound, __pyx_k_getNBestSolsFound, sizeof(__pyx_k_getNBestSolsFound), 0, 0, 1, 1}, + {&__pyx_n_s_getNBinVars, __pyx_k_getNBinVars, sizeof(__pyx_k_getNBinVars), 0, 0, 1, 1}, + {&__pyx_n_s_getNChildren, __pyx_k_getNChildren, sizeof(__pyx_k_getNChildren), 0, 0, 1, 1}, + {&__pyx_n_s_getNConss, __pyx_k_getNConss, sizeof(__pyx_k_getNConss), 0, 0, 1, 1}, + {&__pyx_n_s_getNCountedSols, __pyx_k_getNCountedSols, sizeof(__pyx_k_getNCountedSols), 0, 0, 1, 1}, + {&__pyx_n_s_getNCuts, __pyx_k_getNCuts, sizeof(__pyx_k_getNCuts), 0, 0, 1, 1}, + {&__pyx_n_s_getNCutsApplied, __pyx_k_getNCutsApplied, sizeof(__pyx_k_getNCutsApplied), 0, 0, 1, 1}, + {&__pyx_n_s_getNDomchg, __pyx_k_getNDomchg, sizeof(__pyx_k_getNDomchg), 0, 0, 1, 1}, + {&__pyx_n_s_getNFeasibleLeaves, __pyx_k_getNFeasibleLeaves, sizeof(__pyx_k_getNFeasibleLeaves), 0, 0, 1, 1}, + {&__pyx_n_s_getNInfeasibleLeaves, __pyx_k_getNInfeasibleLeaves, sizeof(__pyx_k_getNInfeasibleLeaves), 0, 0, 1, 1}, + {&__pyx_n_s_getNIntVars, __pyx_k_getNIntVars, sizeof(__pyx_k_getNIntVars), 0, 0, 1, 1}, + {&__pyx_n_s_getNIterations, __pyx_k_getNIterations, sizeof(__pyx_k_getNIterations), 0, 0, 1, 1}, + {&__pyx_n_s_getNLPCols, __pyx_k_getNLPCols, sizeof(__pyx_k_getNLPCols), 0, 0, 1, 1}, + {&__pyx_n_s_getNLPIterations, __pyx_k_getNLPIterations, sizeof(__pyx_k_getNLPIterations), 0, 0, 1, 1}, + {&__pyx_n_s_getNLPNonz, __pyx_k_getNLPNonz, sizeof(__pyx_k_getNLPNonz), 0, 0, 1, 1}, + {&__pyx_n_s_getNLPRows, __pyx_k_getNLPRows, sizeof(__pyx_k_getNLPRows), 0, 0, 1, 1}, + {&__pyx_n_s_getNLPs, __pyx_k_getNLPs, sizeof(__pyx_k_getNLPs), 0, 0, 1, 1}, + {&__pyx_n_s_getNLeaves, __pyx_k_getNLeaves, sizeof(__pyx_k_getNLeaves), 0, 0, 1, 1}, + {&__pyx_n_s_getNLimSolsFound, __pyx_k_getNLimSolsFound, sizeof(__pyx_k_getNLimSolsFound), 0, 0, 1, 1}, + {&__pyx_n_s_getNNlRows, __pyx_k_getNNlRows, sizeof(__pyx_k_getNNlRows), 0, 0, 1, 1}, + {&__pyx_n_s_getNNodes, __pyx_k_getNNodes, sizeof(__pyx_k_getNNodes), 0, 0, 1, 1}, + {&__pyx_n_s_getNNonz, __pyx_k_getNNonz, sizeof(__pyx_k_getNNonz), 0, 0, 1, 1}, + {&__pyx_n_s_getNParentBranchings, __pyx_k_getNParentBranchings, sizeof(__pyx_k_getNParentBranchings), 0, 0, 1, 1}, + {&__pyx_n_s_getNReaders, __pyx_k_getNReaders, sizeof(__pyx_k_getNReaders), 0, 0, 1, 1}, + {&__pyx_n_s_getNSepaRounds, __pyx_k_getNSepaRounds, sizeof(__pyx_k_getNSepaRounds), 0, 0, 1, 1}, + {&__pyx_n_s_getNSiblings, __pyx_k_getNSiblings, sizeof(__pyx_k_getNSiblings), 0, 0, 1, 1}, + {&__pyx_n_s_getNSols, __pyx_k_getNSols, sizeof(__pyx_k_getNSols), 0, 0, 1, 1}, + {&__pyx_n_s_getNSolsFound, __pyx_k_getNSolsFound, sizeof(__pyx_k_getNSolsFound), 0, 0, 1, 1}, + {&__pyx_n_s_getNTotalNodes, __pyx_k_getNTotalNodes, sizeof(__pyx_k_getNTotalNodes), 0, 0, 1, 1}, + {&__pyx_n_s_getNVars, __pyx_k_getNVars, sizeof(__pyx_k_getNVars), 0, 0, 1, 1}, + {&__pyx_n_s_getName, __pyx_k_getName, sizeof(__pyx_k_getName), 0, 0, 1, 1}, + {&__pyx_n_s_getNewBound, __pyx_k_getNewBound, sizeof(__pyx_k_getNewBound), 0, 0, 1, 1}, + {&__pyx_n_s_getNlRowActivityBounds, __pyx_k_getNlRowActivityBounds, sizeof(__pyx_k_getNlRowActivityBounds), 0, 0, 1, 1}, + {&__pyx_n_s_getNlRowSolActivity, __pyx_k_getNlRowSolActivity, sizeof(__pyx_k_getNlRowSolActivity), 0, 0, 1, 1}, + {&__pyx_n_s_getNlRowSolFeasibility, __pyx_k_getNlRowSolFeasibility, sizeof(__pyx_k_getNlRowSolFeasibility), 0, 0, 1, 1}, + {&__pyx_n_s_getNlRows, __pyx_k_getNlRows, sizeof(__pyx_k_getNlRows), 0, 0, 1, 1}, + {&__pyx_n_s_getNode, __pyx_k_getNode, sizeof(__pyx_k_getNode), 0, 0, 1, 1}, + {&__pyx_n_s_getNorm, __pyx_k_getNorm, sizeof(__pyx_k_getNorm), 0, 0, 1, 1}, + {&__pyx_n_s_getNumber, __pyx_k_getNumber, sizeof(__pyx_k_getNumber), 0, 0, 1, 1}, + {&__pyx_n_s_getObj, __pyx_k_getObj, sizeof(__pyx_k_getObj), 0, 0, 1, 1}, + {&__pyx_n_s_getObjCoeff, __pyx_k_getObjCoeff, sizeof(__pyx_k_getObjCoeff), 0, 0, 1, 1}, + {&__pyx_n_s_getObjVal, __pyx_k_getObjVal, sizeof(__pyx_k_getObjVal), 0, 0, 1, 1}, + {&__pyx_n_s_getObjective, __pyx_k_getObjective, sizeof(__pyx_k_getObjective), 0, 0, 1, 1}, + {&__pyx_n_s_getObjectiveSense, __pyx_k_getObjectiveSense, sizeof(__pyx_k_getObjectiveSense), 0, 0, 1, 1}, + {&__pyx_n_s_getObjlimit, __pyx_k_getObjlimit, sizeof(__pyx_k_getObjlimit), 0, 0, 1, 1}, + {&__pyx_n_s_getObjoffset, __pyx_k_getObjoffset, sizeof(__pyx_k_getObjoffset), 0, 0, 1, 1}, + {&__pyx_n_s_getOldBound, __pyx_k_getOldBound, sizeof(__pyx_k_getOldBound), 0, 0, 1, 1}, + {&__pyx_n_s_getOp, __pyx_k_getOp, sizeof(__pyx_k_getOp), 0, 0, 1, 1}, + {&__pyx_n_s_getOpenNodes, __pyx_k_getOpenNodes, sizeof(__pyx_k_getOpenNodes), 0, 0, 1, 1}, + {&__pyx_n_s_getOrigintype, __pyx_k_getOrigintype, sizeof(__pyx_k_getOrigintype), 0, 0, 1, 1}, + {&__pyx_n_s_getParam, __pyx_k_getParam, sizeof(__pyx_k_getParam), 0, 0, 1, 1}, + {&__pyx_n_s_getParams, __pyx_k_getParams, sizeof(__pyx_k_getParams), 0, 0, 1, 1}, + {&__pyx_n_s_getParent, __pyx_k_getParent, sizeof(__pyx_k_getParent), 0, 0, 1, 1}, + {&__pyx_n_s_getParentBranchings, __pyx_k_getParentBranchings, sizeof(__pyx_k_getParentBranchings), 0, 0, 1, 1}, + {&__pyx_n_s_getPresolvingTime, __pyx_k_getPresolvingTime, sizeof(__pyx_k_getPresolvingTime), 0, 0, 1, 1}, + {&__pyx_n_s_getPrimal, __pyx_k_getPrimal, sizeof(__pyx_k_getPrimal), 0, 0, 1, 1}, + {&__pyx_n_s_getPrimalRay, __pyx_k_getPrimalRay, sizeof(__pyx_k_getPrimalRay), 0, 0, 1, 1}, + {&__pyx_n_s_getPrimalRayVal, __pyx_k_getPrimalRayVal, sizeof(__pyx_k_getPrimalRayVal), 0, 0, 1, 1}, + {&__pyx_n_s_getPrimalbound, __pyx_k_getPrimalbound, sizeof(__pyx_k_getPrimalbound), 0, 0, 1, 1}, + {&__pyx_n_s_getPrimsol, __pyx_k_getPrimsol, sizeof(__pyx_k_getPrimsol), 0, 0, 1, 1}, + {&__pyx_n_s_getProbName, __pyx_k_getProbName, sizeof(__pyx_k_getProbName), 0, 0, 1, 1}, + {&__pyx_n_s_getProbingDepth, __pyx_k_getProbingDepth, sizeof(__pyx_k_getProbingDepth), 0, 0, 1, 1}, + {&__pyx_n_s_getPseudoBranchCands, __pyx_k_getPseudoBranchCands, sizeof(__pyx_k_getPseudoBranchCands), 0, 0, 1, 1}, + {&__pyx_n_s_getReadingTime, __pyx_k_getReadingTime, sizeof(__pyx_k_getReadingTime), 0, 0, 1, 1}, + {&__pyx_n_s_getRedcost, __pyx_k_getRedcost, sizeof(__pyx_k_getRedcost), 0, 0, 1, 1}, + {&__pyx_n_s_getRhs, __pyx_k_getRhs, sizeof(__pyx_k_getRhs), 0, 0, 1, 1}, + {&__pyx_n_s_getRow, __pyx_k_getRow, sizeof(__pyx_k_getRow), 0, 0, 1, 1}, + {&__pyx_n_s_getRowActivity, __pyx_k_getRowActivity, sizeof(__pyx_k_getRowActivity), 0, 0, 1, 1}, + {&__pyx_n_s_getRowDualSol, __pyx_k_getRowDualSol, sizeof(__pyx_k_getRowDualSol), 0, 0, 1, 1}, + {&__pyx_n_s_getRowLPActivity, __pyx_k_getRowLPActivity, sizeof(__pyx_k_getRowLPActivity), 0, 0, 1, 1}, + {&__pyx_n_s_getRowLinear, __pyx_k_getRowLinear, sizeof(__pyx_k_getRowLinear), 0, 0, 1, 1}, + {&__pyx_n_s_getRowNumIntCols, __pyx_k_getRowNumIntCols, sizeof(__pyx_k_getRowNumIntCols), 0, 0, 1, 1}, + {&__pyx_n_s_getRowObjParallelism, __pyx_k_getRowObjParallelism, sizeof(__pyx_k_getRowObjParallelism), 0, 0, 1, 1}, + {&__pyx_n_s_getRowParallelism, __pyx_k_getRowParallelism, sizeof(__pyx_k_getRowParallelism), 0, 0, 1, 1}, + {&__pyx_n_s_getSides, __pyx_k_getSides, sizeof(__pyx_k_getSides), 0, 0, 1, 1}, + {&__pyx_n_s_getSlack, __pyx_k_getSlack, sizeof(__pyx_k_getSlack), 0, 0, 1, 1}, + {&__pyx_n_s_getSlackVarIndicator, __pyx_k_getSlackVarIndicator, sizeof(__pyx_k_getSlackVarIndicator), 0, 0, 1, 1}, + {&__pyx_n_s_getSolObjVal, __pyx_k_getSolObjVal, sizeof(__pyx_k_getSolObjVal), 0, 0, 1, 1}, + {&__pyx_n_u_getSolObjVal, __pyx_k_getSolObjVal, sizeof(__pyx_k_getSolObjVal), 0, 1, 0, 1}, + {&__pyx_n_s_getSolTime, __pyx_k_getSolTime, sizeof(__pyx_k_getSolTime), 0, 0, 1, 1}, + {&__pyx_n_s_getSolVal, __pyx_k_getSolVal, sizeof(__pyx_k_getSolVal), 0, 0, 1, 1}, + {&__pyx_n_s_getSols, __pyx_k_getSols, sizeof(__pyx_k_getSols), 0, 0, 1, 1}, + {&__pyx_n_s_getSolvingTime, __pyx_k_getSolvingTime, sizeof(__pyx_k_getSolvingTime), 0, 0, 1, 1}, + {&__pyx_n_s_getStage, __pyx_k_getStage, sizeof(__pyx_k_getStage), 0, 0, 1, 1}, + {&__pyx_n_s_getStageName, __pyx_k_getStageName, sizeof(__pyx_k_getStageName), 0, 0, 1, 1}, + {&__pyx_n_s_getStageNames, __pyx_k_getStageNames, sizeof(__pyx_k_getStageNames), 0, 0, 1, 1}, + {&__pyx_n_s_getStatus, __pyx_k_getStatus, sizeof(__pyx_k_getStatus), 0, 0, 1, 1}, + {&__pyx_n_s_getTermsQuadratic, __pyx_k_getTermsQuadratic, sizeof(__pyx_k_getTermsQuadratic), 0, 0, 1, 1}, + {&__pyx_n_s_getTotalTime, __pyx_k_getTotalTime, sizeof(__pyx_k_getTotalTime), 0, 0, 1, 1}, + {&__pyx_n_s_getTransformedCons, __pyx_k_getTransformedCons, sizeof(__pyx_k_getTransformedCons), 0, 0, 1, 1}, + {&__pyx_n_s_getTransformedVar, __pyx_k_getTransformedVar, sizeof(__pyx_k_getTransformedVar), 0, 0, 1, 1}, + {&__pyx_n_s_getTreesizeEstimation, __pyx_k_getTreesizeEstimation, sizeof(__pyx_k_getTreesizeEstimation), 0, 0, 1, 1}, + {&__pyx_n_s_getType, __pyx_k_getType, sizeof(__pyx_k_getType), 0, 0, 1, 1}, + {&__pyx_n_s_getUb, __pyx_k_getUb, sizeof(__pyx_k_getUb), 0, 0, 1, 1}, + {&__pyx_n_s_getUbGlobal, __pyx_k_getUbGlobal, sizeof(__pyx_k_getUbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_getUbLocal, __pyx_k_getUbLocal, sizeof(__pyx_k_getUbLocal), 0, 0, 1, 1}, + {&__pyx_n_s_getUbOriginal, __pyx_k_getUbOriginal, sizeof(__pyx_k_getUbOriginal), 0, 0, 1, 1}, + {&__pyx_n_s_getVal, __pyx_k_getVal, sizeof(__pyx_k_getVal), 0, 0, 1, 1}, + {&__pyx_n_s_getVals, __pyx_k_getVals, sizeof(__pyx_k_getVals), 0, 0, 1, 1}, + {&__pyx_n_s_getValsLinear, __pyx_k_getValsLinear, sizeof(__pyx_k_getValsLinear), 0, 0, 1, 1}, + {&__pyx_n_s_getVar, __pyx_k_getVar, sizeof(__pyx_k_getVar), 0, 0, 1, 1}, + {&__pyx_n_s_getVarDict, __pyx_k_getVarDict, sizeof(__pyx_k_getVarDict), 0, 0, 1, 1}, + {&__pyx_n_s_getVarLbDive, __pyx_k_getVarLbDive, sizeof(__pyx_k_getVarLbDive), 0, 0, 1, 1}, + {&__pyx_n_s_getVarRedcost, __pyx_k_getVarRedcost, sizeof(__pyx_k_getVarRedcost), 0, 0, 1, 1}, + {&__pyx_n_s_getVarUbDive, __pyx_k_getVarUbDive, sizeof(__pyx_k_getVarUbDive), 0, 0, 1, 1}, + {&__pyx_n_s_getVars, __pyx_k_getVars, sizeof(__pyx_k_getVars), 0, 0, 1, 1}, + {&__pyx_n_s_getitem, __pyx_k_getitem, sizeof(__pyx_k_getitem), 0, 0, 1, 1}, + {&__pyx_n_s_getitem___locals_genexpr, __pyx_k_getitem___locals_genexpr, sizeof(__pyx_k_getitem___locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_getlocale, __pyx_k_getlocale, sizeof(__pyx_k_getlocale), 0, 0, 1, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_give_ownership, __pyx_k_give_ownership, sizeof(__pyx_k_give_ownership), 0, 0, 1, 1}, + {&__pyx_kp_u_given_coefficients_are_neither_E, __pyx_k_given_coefficients_are_neither_E, sizeof(__pyx_k_given_coefficients_are_neither_E), 0, 1, 0, 0}, + {&__pyx_kp_u_given_coefficients_are_not_Expr, __pyx_k_given_coefficients_are_not_Expr, sizeof(__pyx_k_given_coefficients_are_not_Expr), 0, 1, 0, 0}, + {&__pyx_kp_u_given_constraint_is_not_ExprCons, __pyx_k_given_constraint_is_not_ExprCons, sizeof(__pyx_k_given_constraint_is_not_ExprCons), 0, 1, 0, 0}, + {&__pyx_kp_u_given_constraint_is_not_linear_d, __pyx_k_given_constraint_is_not_linear_d, sizeof(__pyx_k_given_constraint_is_not_linear_d), 0, 1, 0, 0}, + {&__pyx_kp_u_given_constraint_is_not_quadrati, __pyx_k_given_constraint_is_not_quadrati, sizeof(__pyx_k_given_constraint_is_not_quadrati), 0, 1, 0, 0}, + {&__pyx_n_s_globalcopy, __pyx_k_globalcopy, sizeof(__pyx_k_globalcopy), 0, 0, 1, 1}, + {&__pyx_n_s_hasPrimalRay, __pyx_k_hasPrimalRay, sizeof(__pyx_k_hasPrimalRay), 0, 0, 1, 1}, + {&__pyx_n_s_hash, __pyx_k_hash, sizeof(__pyx_k_hash), 0, 0, 1, 1}, + {&__pyx_n_s_hashval, __pyx_k_hashval, sizeof(__pyx_k_hashval), 0, 0, 1, 1}, + {&__pyx_n_u_hashval, __pyx_k_hashval, sizeof(__pyx_k_hashval), 0, 1, 0, 1}, + {&__pyx_n_s_heur, __pyx_k_heur, sizeof(__pyx_k_heur), 0, 0, 1, 1}, + {&__pyx_n_s_heur_2, __pyx_k_heur_2, sizeof(__pyx_k_heur_2), 0, 0, 1, 1}, + {&__pyx_n_s_heurexec, __pyx_k_heurexec, sizeof(__pyx_k_heurexec), 0, 0, 1, 1}, + {&__pyx_n_s_heurexit, __pyx_k_heurexit, sizeof(__pyx_k_heurexit), 0, 0, 1, 1}, + {&__pyx_n_s_heurexitsol, __pyx_k_heurexitsol, sizeof(__pyx_k_heurexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_heurfree, __pyx_k_heurfree, sizeof(__pyx_k_heurfree), 0, 0, 1, 1}, + {&__pyx_n_s_heurinit, __pyx_k_heurinit, sizeof(__pyx_k_heurinit), 0, 0, 1, 1}, + {&__pyx_n_s_heurinitsol, __pyx_k_heurinitsol, sizeof(__pyx_k_heurinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_heurtiming, __pyx_k_heurtiming, sizeof(__pyx_k_heurtiming), 0, 0, 1, 1}, + {&__pyx_n_s_hideOutput, __pyx_k_hideOutput, sizeof(__pyx_k_hideOutput), 0, 0, 1, 1}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_idx, __pyx_k_idx, sizeof(__pyx_k_idx), 0, 0, 1, 1}, + {&__pyx_n_s_idxs, __pyx_k_idxs, sizeof(__pyx_k_idxs), 0, 0, 1, 1}, + {&__pyx_n_s_implvars, __pyx_k_implvars, sizeof(__pyx_k_implvars), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_inProbing, __pyx_k_inProbing, sizeof(__pyx_k_inProbing), 0, 0, 1, 1}, + {&__pyx_n_s_inRepropagation, __pyx_k_inRepropagation, sizeof(__pyx_k_inRepropagation), 0, 0, 1, 1}, + {&__pyx_n_s_includeBenders, __pyx_k_includeBenders, sizeof(__pyx_k_includeBenders), 0, 0, 1, 1}, + {&__pyx_n_s_includeBendersDefaultCuts, __pyx_k_includeBendersDefaultCuts, sizeof(__pyx_k_includeBendersDefaultCuts), 0, 0, 1, 1}, + {&__pyx_n_s_includeBenderscut, __pyx_k_includeBenderscut, sizeof(__pyx_k_includeBenderscut), 0, 0, 1, 1}, + {&__pyx_n_s_includeBranchrule, __pyx_k_includeBranchrule, sizeof(__pyx_k_includeBranchrule), 0, 0, 1, 1}, + {&__pyx_n_s_includeConshdlr, __pyx_k_includeConshdlr, sizeof(__pyx_k_includeConshdlr), 0, 0, 1, 1}, + {&__pyx_n_s_includeCutsel, __pyx_k_includeCutsel, sizeof(__pyx_k_includeCutsel), 0, 0, 1, 1}, + {&__pyx_n_s_includeDefaultPlugins, __pyx_k_includeDefaultPlugins, sizeof(__pyx_k_includeDefaultPlugins), 0, 0, 1, 1}, + {&__pyx_n_s_includeEventhdlr, __pyx_k_includeEventhdlr, sizeof(__pyx_k_includeEventhdlr), 0, 0, 1, 1}, + {&__pyx_n_s_includeHeur, __pyx_k_includeHeur, sizeof(__pyx_k_includeHeur), 0, 0, 1, 1}, + {&__pyx_n_s_includeNodesel, __pyx_k_includeNodesel, sizeof(__pyx_k_includeNodesel), 0, 0, 1, 1}, + {&__pyx_n_s_includePresol, __pyx_k_includePresol, sizeof(__pyx_k_includePresol), 0, 0, 1, 1}, + {&__pyx_n_s_includePricer, __pyx_k_includePricer, sizeof(__pyx_k_includePricer), 0, 0, 1, 1}, + {&__pyx_n_s_includeProp, __pyx_k_includeProp, sizeof(__pyx_k_includeProp), 0, 0, 1, 1}, + {&__pyx_n_s_includeReader, __pyx_k_includeReader, sizeof(__pyx_k_includeReader), 0, 0, 1, 1}, + {&__pyx_n_s_includeRelax, __pyx_k_includeRelax, sizeof(__pyx_k_includeRelax), 0, 0, 1, 1}, + {&__pyx_n_s_includeSepa, __pyx_k_includeSepa, sizeof(__pyx_k_includeSepa), 0, 0, 1, 1}, + {&__pyx_n_s_indices, __pyx_k_indices, sizeof(__pyx_k_indices), 0, 0, 1, 1}, + {&__pyx_n_s_inds, __pyx_k_inds, sizeof(__pyx_k_inds), 0, 0, 1, 1}, + {&__pyx_n_s_indvar, __pyx_k_indvar, sizeof(__pyx_k_indvar), 0, 0, 1, 1}, + {&__pyx_n_s_indvars, __pyx_k_indvars, sizeof(__pyx_k_indvars), 0, 0, 1, 1}, + {&__pyx_n_u_inf, __pyx_k_inf, sizeof(__pyx_k_inf), 0, 1, 0, 1}, + {&__pyx_n_s_infeasible, __pyx_k_infeasible, sizeof(__pyx_k_infeasible), 0, 0, 1, 1}, + {&__pyx_n_u_infeasible, __pyx_k_infeasible, sizeof(__pyx_k_infeasible), 0, 1, 0, 1}, + {&__pyx_n_s_infeasible_2, __pyx_k_infeasible_2, sizeof(__pyx_k_infeasible_2), 0, 0, 1, 1}, + {&__pyx_n_s_inferinfo, __pyx_k_inferinfo, sizeof(__pyx_k_inferinfo), 0, 0, 1, 1}, + {&__pyx_n_s_infinity, __pyx_k_infinity, sizeof(__pyx_k_infinity), 0, 0, 1, 1}, + {&__pyx_n_u_inforunbd, __pyx_k_inforunbd, sizeof(__pyx_k_inforunbd), 0, 1, 0, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_initBendersDefault, __pyx_k_initBendersDefault, sizeof(__pyx_k_initBendersDefault), 0, 0, 1, 1}, + {&__pyx_n_s_init_subclass, __pyx_k_init_subclass, sizeof(__pyx_k_init_subclass), 0, 0, 1, 1}, + {&__pyx_n_s_initial, __pyx_k_initial, sizeof(__pyx_k_initial), 0, 0, 1, 1}, + {&__pyx_n_u_initial, __pyx_k_initial, sizeof(__pyx_k_initial), 0, 1, 0, 1}, + {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, + {&__pyx_n_s_interruptSolve, __pyx_k_interruptSolve, sizeof(__pyx_k_interruptSolve), 0, 0, 1, 1}, + {&__pyx_n_s_intvars, __pyx_k_intvars, sizeof(__pyx_k_intvars), 0, 0, 1, 1}, + {&__pyx_n_s_isActive, __pyx_k_isActive, sizeof(__pyx_k_isActive), 0, 0, 1, 1}, + {&__pyx_n_s_isChecked, __pyx_k_isChecked, sizeof(__pyx_k_isChecked), 0, 0, 1, 1}, + {&__pyx_n_s_isCutEfficacious, __pyx_k_isCutEfficacious, sizeof(__pyx_k_isCutEfficacious), 0, 0, 1, 1}, + {&__pyx_n_s_isDualFeasible, __pyx_k_isDualFeasible, sizeof(__pyx_k_isDualFeasible), 0, 0, 1, 1}, + {&__pyx_n_s_isDynamic, __pyx_k_isDynamic, sizeof(__pyx_k_isDynamic), 0, 0, 1, 1}, + {&__pyx_n_s_isEQ, __pyx_k_isEQ, sizeof(__pyx_k_isEQ), 0, 0, 1, 1}, + {&__pyx_n_s_isEnforced, __pyx_k_isEnforced, sizeof(__pyx_k_isEnforced), 0, 0, 1, 1}, + {&__pyx_n_s_isFeasEQ, __pyx_k_isFeasEQ, sizeof(__pyx_k_isFeasEQ), 0, 0, 1, 1}, + {&__pyx_n_s_isFeasIntegral, __pyx_k_isFeasIntegral, sizeof(__pyx_k_isFeasIntegral), 0, 0, 1, 1}, + {&__pyx_n_s_isFeasNegative, __pyx_k_isFeasNegative, sizeof(__pyx_k_isFeasNegative), 0, 0, 1, 1}, + {&__pyx_n_s_isFeasZero, __pyx_k_isFeasZero, sizeof(__pyx_k_isFeasZero), 0, 0, 1, 1}, + {&__pyx_n_s_isGE, __pyx_k_isGE, sizeof(__pyx_k_isGE), 0, 0, 1, 1}, + {&__pyx_n_s_isGT, __pyx_k_isGT, sizeof(__pyx_k_isGT), 0, 0, 1, 1}, + {&__pyx_n_s_isInGlobalCutpool, __pyx_k_isInGlobalCutpool, sizeof(__pyx_k_isInGlobalCutpool), 0, 0, 1, 1}, + {&__pyx_n_s_isInLP, __pyx_k_isInLP, sizeof(__pyx_k_isInLP), 0, 0, 1, 1}, + {&__pyx_n_s_isInfinity, __pyx_k_isInfinity, sizeof(__pyx_k_isInfinity), 0, 0, 1, 1}, + {&__pyx_n_s_isInitial, __pyx_k_isInitial, sizeof(__pyx_k_isInitial), 0, 0, 1, 1}, + {&__pyx_n_s_isIntegral, __pyx_k_isIntegral, sizeof(__pyx_k_isIntegral), 0, 0, 1, 1}, + {&__pyx_n_s_isLE, __pyx_k_isLE, sizeof(__pyx_k_isLE), 0, 0, 1, 1}, + {&__pyx_n_s_isLPSolBasic, __pyx_k_isLPSolBasic, sizeof(__pyx_k_isLPSolBasic), 0, 0, 1, 1}, + {&__pyx_n_s_isLT, __pyx_k_isLT, sizeof(__pyx_k_isLT), 0, 0, 1, 1}, + {&__pyx_n_s_isLinear, __pyx_k_isLinear, sizeof(__pyx_k_isLinear), 0, 0, 1, 1}, + {&__pyx_n_s_isLocal, __pyx_k_isLocal, sizeof(__pyx_k_isLocal), 0, 0, 1, 1}, + {&__pyx_n_s_isModifiable, __pyx_k_isModifiable, sizeof(__pyx_k_isModifiable), 0, 0, 1, 1}, + {&__pyx_n_s_isNLPConstructed, __pyx_k_isNLPConstructed, sizeof(__pyx_k_isNLPConstructed), 0, 0, 1, 1}, + {&__pyx_n_s_isNonlinear, __pyx_k_isNonlinear, sizeof(__pyx_k_isNonlinear), 0, 0, 1, 1}, + {&__pyx_n_s_isObjChangedProbing, __pyx_k_isObjChangedProbing, sizeof(__pyx_k_isObjChangedProbing), 0, 0, 1, 1}, + {&__pyx_n_s_isOriginal, __pyx_k_isOriginal, sizeof(__pyx_k_isOriginal), 0, 0, 1, 1}, + {&__pyx_n_s_isPrimalFeasible, __pyx_k_isPrimalFeasible, sizeof(__pyx_k_isPrimalFeasible), 0, 0, 1, 1}, + {&__pyx_n_s_isPropagated, __pyx_k_isPropagated, sizeof(__pyx_k_isPropagated), 0, 0, 1, 1}, + {&__pyx_n_s_isPropagatedAgain, __pyx_k_isPropagatedAgain, sizeof(__pyx_k_isPropagatedAgain), 0, 0, 1, 1}, + {&__pyx_n_s_isRedundant, __pyx_k_isRedundant, sizeof(__pyx_k_isRedundant), 0, 0, 1, 1}, + {&__pyx_n_s_isRemovable, __pyx_k_isRemovable, sizeof(__pyx_k_isRemovable), 0, 0, 1, 1}, + {&__pyx_n_s_isSeparated, __pyx_k_isSeparated, sizeof(__pyx_k_isSeparated), 0, 0, 1, 1}, + {&__pyx_n_s_isStickingAtNode, __pyx_k_isStickingAtNode, sizeof(__pyx_k_isStickingAtNode), 0, 0, 1, 1}, + {&__pyx_n_s_isZero, __pyx_k_isZero, sizeof(__pyx_k_isZero), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_n_s_is_integer, __pyx_k_is_integer, sizeof(__pyx_k_is_integer), 0, 0, 1, 1}, + {&__pyx_n_s_is_memory_freed, __pyx_k_is_memory_freed, sizeof(__pyx_k_is_memory_freed), 0, 0, 1, 1}, + {&__pyx_n_s_is_number, __pyx_k_is_number, sizeof(__pyx_k_is_number), 0, 0, 1, 1}, + {&__pyx_n_s_isconvex, __pyx_k_isconvex, sizeof(__pyx_k_isconvex), 0, 0, 1, 1}, + {&__pyx_n_s_isdict, __pyx_k_isdict, sizeof(__pyx_k_isdict), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_s_islpcut, __pyx_k_islpcut, sizeof(__pyx_k_islpcut), 0, 0, 1, 1}, + {&__pyx_n_s_isquadratic, __pyx_k_isquadratic, sizeof(__pyx_k_isquadratic), 0, 0, 1, 1}, + {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, + {&__pyx_n_s_iters, __pyx_k_iters, sizeof(__pyx_k_iters), 0, 0, 1, 1}, + {&__pyx_n_s_itertools, __pyx_k_itertools, sizeof(__pyx_k_itertools), 0, 0, 1, 1}, + {&__pyx_n_s_itlim, __pyx_k_itlim, sizeof(__pyx_k_itlim), 0, 0, 1, 1}, + {&__pyx_n_s_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, + {&__pyx_n_s_key, __pyx_k_key, sizeof(__pyx_k_key), 0, 0, 1, 1}, + {&__pyx_n_s_keys, __pyx_k_keys, sizeof(__pyx_k_keys), 0, 0, 1, 1}, + {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1}, + {&__pyx_n_s_lambda, __pyx_k_lambda, sizeof(__pyx_k_lambda), 0, 0, 1, 1}, + {&__pyx_n_s_lastcol, __pyx_k_lastcol, sizeof(__pyx_k_lastcol), 0, 0, 1, 1}, + {&__pyx_n_s_lastrow, __pyx_k_lastrow, sizeof(__pyx_k_lastrow), 0, 0, 1, 1}, + {&__pyx_n_s_lb, __pyx_k_lb, sizeof(__pyx_k_lb), 0, 0, 1, 1}, + {&__pyx_n_s_lbs, __pyx_k_lbs, sizeof(__pyx_k_lbs), 0, 0, 1, 1}, + {&__pyx_n_s_leaves, __pyx_k_leaves, sizeof(__pyx_k_leaves), 0, 0, 1, 1}, + {&__pyx_n_s_leaves_2, __pyx_k_leaves_2, sizeof(__pyx_k_leaves_2), 0, 0, 1, 1}, + {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1}, + {&__pyx_n_s_length, __pyx_k_length, sizeof(__pyx_k_length), 0, 0, 1, 1}, + {&__pyx_n_s_lhs, __pyx_k_lhs, sizeof(__pyx_k_lhs), 0, 0, 1, 1}, + {&__pyx_n_u_lhs, __pyx_k_lhs, sizeof(__pyx_k_lhs), 0, 1, 0, 1}, + {&__pyx_n_s_lhs_2, __pyx_k_lhs_2, sizeof(__pyx_k_lhs_2), 0, 0, 1, 1}, + {&__pyx_n_s_lhss, __pyx_k_lhss, sizeof(__pyx_k_lhss), 0, 0, 1, 1}, + {&__pyx_n_s_lhsslack, __pyx_k_lhsslack, sizeof(__pyx_k_lhsslack), 0, 0, 1, 1}, + {&__pyx_n_s_lincoef, __pyx_k_lincoef, sizeof(__pyx_k_lincoef), 0, 0, 1, 1}, + {&__pyx_n_s_lincoefs, __pyx_k_lincoefs, sizeof(__pyx_k_lincoefs), 0, 0, 1, 1}, + {&__pyx_n_s_lincoefs_2, __pyx_k_lincoefs_2, sizeof(__pyx_k_lincoefs_2), 0, 0, 1, 1}, + {&__pyx_n_s_lincons, __pyx_k_lincons, sizeof(__pyx_k_lincons), 0, 0, 1, 1}, + {&__pyx_n_u_linear, __pyx_k_linear, sizeof(__pyx_k_linear), 0, 1, 0, 1}, + {&__pyx_n_s_linexprs, __pyx_k_linexprs, sizeof(__pyx_k_linexprs), 0, 0, 1, 1}, + {&__pyx_kp_u_linked_SCIP_is_not_compatible_to, __pyx_k_linked_SCIP_is_not_compatible_to, sizeof(__pyx_k_linked_SCIP_is_not_compatible_to), 0, 1, 0, 0}, + {&__pyx_kp_u_linked_SCIP_is_not_recommended_f, __pyx_k_linked_SCIP_is_not_recommended_f, sizeof(__pyx_k_linked_SCIP_is_not_recommended_f), 0, 1, 0, 0}, + {&__pyx_n_s_linterms, __pyx_k_linterms, sizeof(__pyx_k_linterms), 0, 0, 1, 1}, + {&__pyx_n_s_linvars, __pyx_k_linvars, sizeof(__pyx_k_linvars), 0, 0, 1, 1}, + {&__pyx_n_s_local, __pyx_k_local, sizeof(__pyx_k_local), 0, 0, 1, 1}, + {&__pyx_n_u_local, __pyx_k_local, sizeof(__pyx_k_local), 0, 1, 0, 1}, + {&__pyx_n_s_locale, __pyx_k_locale, sizeof(__pyx_k_locale), 0, 0, 1, 1}, + {&__pyx_n_s_locktype, __pyx_k_locktype, sizeof(__pyx_k_locktype), 0, 0, 1, 1}, + {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1}, + {&__pyx_n_u_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 1, 0, 1}, + {&__pyx_n_u_lower, __pyx_k_lower, sizeof(__pyx_k_lower), 0, 1, 0, 1}, + {&__pyx_n_u_lowerbound, __pyx_k_lowerbound, sizeof(__pyx_k_lowerbound), 0, 1, 0, 1}, + {&__pyx_n_s_lowerbounds, __pyx_k_lowerbounds, sizeof(__pyx_k_lowerbounds), 0, 0, 1, 1}, + {&__pyx_n_s_lpcands, __pyx_k_lpcands, sizeof(__pyx_k_lpcands), 0, 0, 1, 1}, + {&__pyx_n_s_lpcandsfrac, __pyx_k_lpcandsfrac, sizeof(__pyx_k_lpcandsfrac), 0, 0, 1, 1}, + {&__pyx_n_s_lpcandssol, __pyx_k_lpcandssol, sizeof(__pyx_k_lpcandssol), 0, 0, 1, 1}, + {&__pyx_n_s_lperror, __pyx_k_lperror, sizeof(__pyx_k_lperror), 0, 0, 1, 1}, + {&__pyx_n_s_lpi, __pyx_k_lpi, sizeof(__pyx_k_lpi), 0, 0, 1, 1}, + {&__pyx_n_s_lpiGetIterations, __pyx_k_lpiGetIterations, sizeof(__pyx_k_lpiGetIterations), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_map, __pyx_k_map, sizeof(__pyx_k_map), 0, 0, 1, 1}, + {&__pyx_n_s_mappedvar, __pyx_k_mappedvar, sizeof(__pyx_k_mappedvar), 0, 0, 1, 1}, + {&__pyx_n_u_mappedvar, __pyx_k_mappedvar, sizeof(__pyx_k_mappedvar), 0, 1, 0, 1}, + {&__pyx_n_s_mappedvar_2, __pyx_k_mappedvar_2, sizeof(__pyx_k_mappedvar_2), 0, 0, 1, 1}, + {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, + {&__pyx_n_s_maxactivity, __pyx_k_maxactivity, sizeof(__pyx_k_maxactivity), 0, 0, 1, 1}, + {&__pyx_n_s_maxbounddist, __pyx_k_maxbounddist, sizeof(__pyx_k_maxbounddist), 0, 0, 1, 1}, + {&__pyx_n_s_maxdepth, __pyx_k_maxdepth, sizeof(__pyx_k_maxdepth), 0, 0, 1, 1}, + {&__pyx_n_u_maximize, __pyx_k_maximize, sizeof(__pyx_k_maximize), 0, 1, 0, 1}, + {&__pyx_n_s_maxnconss, __pyx_k_maxnconss, sizeof(__pyx_k_maxnconss), 0, 0, 1, 1}, + {&__pyx_n_s_maxnselectedcuts, __pyx_k_maxnselectedcuts, sizeof(__pyx_k_maxnselectedcuts), 0, 0, 1, 1}, + {&__pyx_n_s_maxprerounds, __pyx_k_maxprerounds, sizeof(__pyx_k_maxprerounds), 0, 0, 1, 1}, + {&__pyx_n_s_maxproprounds, __pyx_k_maxproprounds, sizeof(__pyx_k_maxproprounds), 0, 0, 1, 1}, + {&__pyx_n_s_maxrounds, __pyx_k_maxrounds, sizeof(__pyx_k_maxrounds), 0, 0, 1, 1}, + {&__pyx_n_u_memlimit, __pyx_k_memlimit, sizeof(__pyx_k_memlimit), 0, 1, 0, 1}, + {&__pyx_n_s_memsavepriority, __pyx_k_memsavepriority, sizeof(__pyx_k_memsavepriority), 0, 0, 1, 1}, + {&__pyx_n_s_mergecandidates, __pyx_k_mergecandidates, sizeof(__pyx_k_mergecandidates), 0, 0, 1, 1}, + {&__pyx_n_u_merged, __pyx_k_merged, sizeof(__pyx_k_merged), 0, 1, 0, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_method, __pyx_k_method, sizeof(__pyx_k_method), 0, 0, 1, 1}, + {&__pyx_kp_u_method_can_only_be_called_in_sta, __pyx_k_method_can_only_be_called_in_sta, sizeof(__pyx_k_method_can_only_be_called_in_sta), 0, 1, 0, 0}, + {&__pyx_kp_u_method_cannot_be_called_before_p, __pyx_k_method_cannot_be_called_before_p, sizeof(__pyx_k_method_cannot_be_called_before_p), 0, 1, 0, 0}, + {&__pyx_kp_u_method_cannot_be_called_for_cons, __pyx_k_method_cannot_be_called_for_cons, sizeof(__pyx_k_method_cannot_be_called_for_cons), 0, 1, 0, 0}, + {&__pyx_n_s_minactivity, __pyx_k_minactivity, sizeof(__pyx_k_minactivity), 0, 0, 1, 1}, + {&__pyx_n_u_minimize, __pyx_k_minimize, sizeof(__pyx_k_minimize), 0, 1, 0, 1}, + {&__pyx_n_s_minus, __pyx_k_minus, sizeof(__pyx_k_minus), 0, 0, 1, 1}, + {&__pyx_n_s_model, __pyx_k_model, sizeof(__pyx_k_model), 0, 0, 1, 1}, + {&__pyx_n_u_model, __pyx_k_model, sizeof(__pyx_k_model), 0, 1, 0, 1}, + {&__pyx_kp_u_model_cip, __pyx_k_model_cip, sizeof(__pyx_k_model_cip), 0, 1, 0, 0}, + {&__pyx_kp_u_model_getDualMultiplier_cons_is, __pyx_k_model_getDualMultiplier_cons_is, sizeof(__pyx_k_model_getDualMultiplier_cons_is), 0, 1, 0, 0}, + {&__pyx_n_s_modifiable, __pyx_k_modifiable, sizeof(__pyx_k_modifiable), 0, 0, 1, 1}, + {&__pyx_n_u_modifiable, __pyx_k_modifiable, sizeof(__pyx_k_modifiable), 0, 1, 0, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_monomials, __pyx_k_monomials, sizeof(__pyx_k_monomials), 0, 0, 1, 1}, + {&__pyx_n_s_mul, __pyx_k_mul, sizeof(__pyx_k_mul), 0, 0, 1, 1}, + {&__pyx_n_s_mul_2, __pyx_k_mul_2, sizeof(__pyx_k_mul_2), 0, 0, 1, 1}, + {&__pyx_n_s_myMessageHandler, __pyx_k_myMessageHandler, sizeof(__pyx_k_myMessageHandler), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_n_s_n_conss, __pyx_k_n_conss, sizeof(__pyx_k_n_conss), 0, 0, 1, 1}, + {&__pyx_n_u_naddconss, __pyx_k_naddconss, sizeof(__pyx_k_naddconss), 0, 1, 0, 1}, + {&__pyx_n_u_naddholes, __pyx_k_naddholes, sizeof(__pyx_k_naddholes), 0, 1, 0, 1}, + {&__pyx_n_u_naggrvars, __pyx_k_naggrvars, sizeof(__pyx_k_naggrvars), 0, 1, 0, 1}, + {&__pyx_n_s_nam, __pyx_k_nam, sizeof(__pyx_k_nam), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_nbenders, __pyx_k_nbenders, sizeof(__pyx_k_nbenders), 0, 0, 1, 1}, + {&__pyx_n_s_nbilinterms, __pyx_k_nbilinterms, sizeof(__pyx_k_nbilinterms), 0, 0, 1, 1}, + {&__pyx_n_s_nboundchgs, __pyx_k_nboundchgs, sizeof(__pyx_k_nboundchgs), 0, 0, 1, 1}, + {&__pyx_n_s_nbranchings, __pyx_k_nbranchings, sizeof(__pyx_k_nbranchings), 0, 0, 1, 1}, + {&__pyx_n_s_nbranchvars, __pyx_k_nbranchvars, sizeof(__pyx_k_nbranchvars), 0, 0, 1, 1}, + {&__pyx_n_s_ncands, __pyx_k_ncands, sizeof(__pyx_k_ncands), 0, 0, 1, 1}, + {&__pyx_n_u_nchgbds, __pyx_k_nchgbds, sizeof(__pyx_k_nchgbds), 0, 1, 0, 1}, + {&__pyx_n_u_nchgcoefs, __pyx_k_nchgcoefs, sizeof(__pyx_k_nchgcoefs), 0, 1, 0, 1}, + {&__pyx_n_u_nchgsides, __pyx_k_nchgsides, sizeof(__pyx_k_nchgsides), 0, 1, 0, 1}, + {&__pyx_n_u_nchgvartypes, __pyx_k_nchgvartypes, sizeof(__pyx_k_nchgvartypes), 0, 1, 0, 1}, + {&__pyx_n_s_nchildren, __pyx_k_nchildren, sizeof(__pyx_k_nchildren), 0, 0, 1, 1}, + {&__pyx_n_s_nchildren_2, __pyx_k_nchildren_2, sizeof(__pyx_k_nchildren_2), 0, 0, 1, 1}, + {&__pyx_n_s_ncols, __pyx_k_ncols, sizeof(__pyx_k_ncols), 0, 0, 1, 1}, + {&__pyx_n_s_nconsprop, __pyx_k_nconsprop, sizeof(__pyx_k_nconsprop), 0, 0, 1, 1}, + {&__pyx_n_s_nconss, __pyx_k_nconss, sizeof(__pyx_k_nconss), 0, 0, 1, 1}, + {&__pyx_n_s_nconss_2, __pyx_k_nconss_2, sizeof(__pyx_k_nconss_2), 0, 0, 1, 1}, + {&__pyx_n_u_ndelconss, __pyx_k_ndelconss, sizeof(__pyx_k_ndelconss), 0, 1, 0, 1}, + {&__pyx_n_s_ndomredsfound, __pyx_k_ndomredsfound, sizeof(__pyx_k_ndomredsfound), 0, 0, 1, 1}, + {&__pyx_n_s_needscons, __pyx_k_needscons, sizeof(__pyx_k_needscons), 0, 0, 1, 1}, + {&__pyx_n_s_negate, __pyx_k_negate, sizeof(__pyx_k_negate), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_n_s_newCheck, __pyx_k_newCheck, sizeof(__pyx_k_newCheck), 0, 0, 1, 1}, + {&__pyx_n_s_newEnf, __pyx_k_newEnf, sizeof(__pyx_k_newEnf), 0, 0, 1, 1}, + {&__pyx_n_s_newInit, __pyx_k_newInit, sizeof(__pyx_k_newInit), 0, 0, 1, 1}, + {&__pyx_n_s_newProbingNode, __pyx_k_newProbingNode, sizeof(__pyx_k_newProbingNode), 0, 0, 1, 1}, + {&__pyx_n_s_newRem, __pyx_k_newRem, sizeof(__pyx_k_newRem), 0, 0, 1, 1}, + {&__pyx_n_s_newbound, __pyx_k_newbound, sizeof(__pyx_k_newbound), 0, 0, 1, 1}, + {&__pyx_n_s_newlhs, __pyx_k_newlhs, sizeof(__pyx_k_newlhs), 0, 0, 1, 1}, + {&__pyx_n_s_newobj, __pyx_k_newobj, sizeof(__pyx_k_newobj), 0, 0, 1, 1}, + {&__pyx_n_s_newrhs, __pyx_k_newrhs, sizeof(__pyx_k_newrhs), 0, 0, 1, 1}, + {&__pyx_n_s_newval, __pyx_k_newval, sizeof(__pyx_k_newval), 0, 0, 1, 1}, + {&__pyx_n_u_nfixedvars, __pyx_k_nfixedvars, sizeof(__pyx_k_nfixedvars), 0, 1, 0, 1}, + {&__pyx_n_s_nfracimplvars, __pyx_k_nfracimplvars, sizeof(__pyx_k_nfracimplvars), 0, 0, 1, 1}, + {&__pyx_n_s_niters, __pyx_k_niters, sizeof(__pyx_k_niters), 0, 0, 1, 1}, + {&__pyx_n_s_nleaves, __pyx_k_nleaves, sizeof(__pyx_k_nleaves), 0, 0, 1, 1}, + {&__pyx_n_s_nlinvars, __pyx_k_nlinvars, sizeof(__pyx_k_nlinvars), 0, 0, 1, 1}, + {&__pyx_n_s_nlinvars_2, __pyx_k_nlinvars_2, sizeof(__pyx_k_nlinvars_2), 0, 0, 1, 1}, + {&__pyx_n_s_nlocksdown, __pyx_k_nlocksdown, sizeof(__pyx_k_nlocksdown), 0, 0, 1, 1}, + {&__pyx_n_s_nlocksneg, __pyx_k_nlocksneg, sizeof(__pyx_k_nlocksneg), 0, 0, 1, 1}, + {&__pyx_n_s_nlockspos, __pyx_k_nlockspos, sizeof(__pyx_k_nlockspos), 0, 0, 1, 1}, + {&__pyx_n_s_nlocksup, __pyx_k_nlocksup, sizeof(__pyx_k_nlocksup), 0, 0, 1, 1}, + {&__pyx_n_s_nlpcands, __pyx_k_nlpcands, sizeof(__pyx_k_nlpcands), 0, 0, 1, 1}, + {&__pyx_n_s_nlrow, __pyx_k_nlrow, sizeof(__pyx_k_nlrow), 0, 0, 1, 1}, + {&__pyx_n_s_nlrows, __pyx_k_nlrows, sizeof(__pyx_k_nlrows), 0, 0, 1, 1}, + {&__pyx_n_s_nmarkedconss, __pyx_k_nmarkedconss, sizeof(__pyx_k_nmarkedconss), 0, 0, 1, 1}, + {&__pyx_n_s_nnewaddconss, __pyx_k_nnewaddconss, sizeof(__pyx_k_nnewaddconss), 0, 0, 1, 1}, + {&__pyx_n_u_nnewaddconss, __pyx_k_nnewaddconss, sizeof(__pyx_k_nnewaddconss), 0, 1, 0, 1}, + {&__pyx_n_u_nnewaddholes, __pyx_k_nnewaddholes, sizeof(__pyx_k_nnewaddholes), 0, 1, 0, 1}, + {&__pyx_n_s_nnewaggrvars, __pyx_k_nnewaggrvars, sizeof(__pyx_k_nnewaggrvars), 0, 0, 1, 1}, + {&__pyx_n_u_nnewaggrvars, __pyx_k_nnewaggrvars, sizeof(__pyx_k_nnewaggrvars), 0, 1, 0, 1}, + {&__pyx_n_s_nnewchgbds, __pyx_k_nnewchgbds, sizeof(__pyx_k_nnewchgbds), 0, 0, 1, 1}, + {&__pyx_n_u_nnewchgbds, __pyx_k_nnewchgbds, sizeof(__pyx_k_nnewchgbds), 0, 1, 0, 1}, + {&__pyx_n_s_nnewchgcoefs, __pyx_k_nnewchgcoefs, sizeof(__pyx_k_nnewchgcoefs), 0, 0, 1, 1}, + {&__pyx_n_u_nnewchgcoefs, __pyx_k_nnewchgcoefs, sizeof(__pyx_k_nnewchgcoefs), 0, 1, 0, 1}, + {&__pyx_n_s_nnewchgsides, __pyx_k_nnewchgsides, sizeof(__pyx_k_nnewchgsides), 0, 0, 1, 1}, + {&__pyx_n_u_nnewchgsides, __pyx_k_nnewchgsides, sizeof(__pyx_k_nnewchgsides), 0, 1, 0, 1}, + {&__pyx_n_s_nnewchgvartypes, __pyx_k_nnewchgvartypes, sizeof(__pyx_k_nnewchgvartypes), 0, 0, 1, 1}, + {&__pyx_n_u_nnewchgvartypes, __pyx_k_nnewchgvartypes, sizeof(__pyx_k_nnewchgvartypes), 0, 1, 0, 1}, + {&__pyx_n_s_nnewdelconss, __pyx_k_nnewdelconss, sizeof(__pyx_k_nnewdelconss), 0, 0, 1, 1}, + {&__pyx_n_u_nnewdelconss, __pyx_k_nnewdelconss, sizeof(__pyx_k_nnewdelconss), 0, 1, 0, 1}, + {&__pyx_n_s_nnewfixedvars, __pyx_k_nnewfixedvars, sizeof(__pyx_k_nnewfixedvars), 0, 0, 1, 1}, + {&__pyx_n_u_nnewfixedvars, __pyx_k_nnewfixedvars, sizeof(__pyx_k_nnewfixedvars), 0, 1, 0, 1}, + {&__pyx_n_s_nnewholes, __pyx_k_nnewholes, sizeof(__pyx_k_nnewholes), 0, 0, 1, 1}, + {&__pyx_n_s_nnewupgdconss, __pyx_k_nnewupgdconss, sizeof(__pyx_k_nnewupgdconss), 0, 0, 1, 1}, + {&__pyx_n_u_nnewupgdconss, __pyx_k_nnewupgdconss, sizeof(__pyx_k_nnewupgdconss), 0, 1, 0, 1}, + {&__pyx_n_s_nnonz, __pyx_k_nnonz, sizeof(__pyx_k_nnonz), 0, 0, 1, 1}, + {&__pyx_kp_u_no_reduced_cost_available_for_va, __pyx_k_no_reduced_cost_available_for_va, sizeof(__pyx_k_no_reduced_cost_available_for_va), 0, 1, 0, 0}, + {&__pyx_n_s_node, __pyx_k_node, sizeof(__pyx_k_node), 0, 0, 1, 1}, + {&__pyx_n_s_node1, __pyx_k_node1, sizeof(__pyx_k_node1), 0, 0, 1, 1}, + {&__pyx_n_s_node2, __pyx_k_node2, sizeof(__pyx_k_node2), 0, 0, 1, 1}, + {&__pyx_n_s_nodecomp, __pyx_k_nodecomp, sizeof(__pyx_k_nodecomp), 0, 0, 1, 1}, + {&__pyx_n_s_nodeexit, __pyx_k_nodeexit, sizeof(__pyx_k_nodeexit), 0, 0, 1, 1}, + {&__pyx_n_s_nodeexitsol, __pyx_k_nodeexitsol, sizeof(__pyx_k_nodeexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_nodefree, __pyx_k_nodefree, sizeof(__pyx_k_nodefree), 0, 0, 1, 1}, + {&__pyx_n_s_nodeinfeasible, __pyx_k_nodeinfeasible, sizeof(__pyx_k_nodeinfeasible), 0, 0, 1, 1}, + {&__pyx_n_s_nodeinit, __pyx_k_nodeinit, sizeof(__pyx_k_nodeinit), 0, 0, 1, 1}, + {&__pyx_n_s_nodeinitsol, __pyx_k_nodeinitsol, sizeof(__pyx_k_nodeinitsol), 0, 0, 1, 1}, + {&__pyx_n_u_nodelimit, __pyx_k_nodelimit, sizeof(__pyx_k_nodelimit), 0, 1, 0, 1}, + {&__pyx_n_s_nodes, __pyx_k_nodes, sizeof(__pyx_k_nodes), 0, 0, 1, 1}, + {&__pyx_n_s_nodesel, __pyx_k_nodesel, sizeof(__pyx_k_nodesel), 0, 0, 1, 1}, + {&__pyx_n_s_nodeselect, __pyx_k_nodeselect, sizeof(__pyx_k_nodeselect), 0, 0, 1, 1}, + {&__pyx_n_s_nodeselprio, __pyx_k_nodeselprio, sizeof(__pyx_k_nodeselprio), 0, 0, 1, 1}, + {&__pyx_n_u_nonlinear, __pyx_k_nonlinear, sizeof(__pyx_k_nonlinear), 0, 1, 0, 1}, + {&__pyx_n_s_normalize, __pyx_k_normalize, sizeof(__pyx_k_normalize), 0, 0, 1, 1}, + {&__pyx_n_s_npriolpcands, __pyx_k_npriolpcands, sizeof(__pyx_k_npriolpcands), 0, 0, 1, 1}, + {&__pyx_n_s_npriomergecands, __pyx_k_npriomergecands, sizeof(__pyx_k_npriomergecands), 0, 0, 1, 1}, + {&__pyx_n_s_npriopseudocands, __pyx_k_npriopseudocands, sizeof(__pyx_k_npriopseudocands), 0, 0, 1, 1}, + {&__pyx_n_s_nprop, __pyx_k_nprop, sizeof(__pyx_k_nprop), 0, 0, 1, 1}, + {&__pyx_n_s_npseudocands, __pyx_k_npseudocands, sizeof(__pyx_k_npseudocands), 0, 0, 1, 1}, + {&__pyx_n_s_nquadterms, __pyx_k_nquadterms, sizeof(__pyx_k_nquadterms), 0, 0, 1, 1}, + {&__pyx_n_s_nrounds, __pyx_k_nrounds, sizeof(__pyx_k_nrounds), 0, 0, 1, 1}, + {&__pyx_n_s_nrows, __pyx_k_nrows, sizeof(__pyx_k_nrows), 0, 0, 1, 1}, + {&__pyx_n_u_nselectedcuts, __pyx_k_nselectedcuts, sizeof(__pyx_k_nselectedcuts), 0, 1, 0, 1}, + {&__pyx_n_s_nsiblings, __pyx_k_nsiblings, sizeof(__pyx_k_nsiblings), 0, 0, 1, 1}, + {&__pyx_n_s_nsols, __pyx_k_nsols, sizeof(__pyx_k_nsols), 0, 0, 1, 1}, + {&__pyx_n_s_nsubproblems, __pyx_k_nsubproblems, sizeof(__pyx_k_nsubproblems), 0, 0, 1, 1}, + {&__pyx_n_s_number, __pyx_k_number, sizeof(__pyx_k_number), 0, 0, 1, 1}, + {&__pyx_n_u_nupgdconss, __pyx_k_nupgdconss, sizeof(__pyx_k_nupgdconss), 0, 1, 0, 1}, + {&__pyx_n_s_nusefulconss, __pyx_k_nusefulconss, sizeof(__pyx_k_nusefulconss), 0, 0, 1, 1}, + {&__pyx_n_s_nvars, __pyx_k_nvars, sizeof(__pyx_k_nvars), 0, 0, 1, 1}, + {&__pyx_n_u_nvars, __pyx_k_nvars, sizeof(__pyx_k_nvars), 0, 1, 0, 1}, + {&__pyx_n_s_nvars_2, __pyx_k_nvars_2, sizeof(__pyx_k_nvars_2), 0, 0, 1, 1}, + {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, + {&__pyx_n_s_objective, __pyx_k_objective, sizeof(__pyx_k_objective), 0, 0, 1, 1}, + {&__pyx_n_u_objective, __pyx_k_objective, sizeof(__pyx_k_objective), 0, 1, 0, 1}, + {&__pyx_n_s_objinfeasible, __pyx_k_objinfeasible, sizeof(__pyx_k_objinfeasible), 0, 0, 1, 1}, + {&__pyx_n_s_objlimit, __pyx_k_objlimit, sizeof(__pyx_k_objlimit), 0, 0, 1, 1}, + {&__pyx_n_s_objoffset, __pyx_k_objoffset, sizeof(__pyx_k_objoffset), 0, 0, 1, 1}, + {&__pyx_n_s_objs, __pyx_k_objs, sizeof(__pyx_k_objs), 0, 0, 1, 1}, + {&__pyx_n_s_objscale, __pyx_k_objscale, sizeof(__pyx_k_objscale), 0, 0, 1, 1}, + {&__pyx_n_s_objsense, __pyx_k_objsense, sizeof(__pyx_k_objsense), 0, 0, 1, 1}, + {&__pyx_n_s_objval, __pyx_k_objval, sizeof(__pyx_k_objval), 0, 0, 1, 1}, + {&__pyx_n_s_offset, __pyx_k_offset, sizeof(__pyx_k_offset), 0, 0, 1, 1}, + {&__pyx_n_s_onlychanged, __pyx_k_onlychanged, sizeof(__pyx_k_onlychanged), 0, 0, 1, 1}, + {&__pyx_n_s_onlyconvex, __pyx_k_onlyconvex, sizeof(__pyx_k_onlyconvex), 0, 0, 1, 1}, + {&__pyx_n_s_onlydelayed, __pyx_k_onlydelayed, sizeof(__pyx_k_onlydelayed), 0, 0, 1, 1}, + {&__pyx_n_s_onlyroot, __pyx_k_onlyroot, sizeof(__pyx_k_onlyroot), 0, 0, 1, 1}, + {&__pyx_n_s_op, __pyx_k_op, sizeof(__pyx_k_op), 0, 0, 1, 1}, + {&__pyx_n_s_op_2, __pyx_k_op_2, sizeof(__pyx_k_op_2), 0, 0, 1, 1}, + {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1}, + {&__pyx_n_s_opidx, __pyx_k_opidx, sizeof(__pyx_k_opidx), 0, 0, 1, 1}, + {&__pyx_n_s_optimal, __pyx_k_optimal, sizeof(__pyx_k_optimal), 0, 0, 1, 1}, + {&__pyx_n_u_optimal, __pyx_k_optimal, sizeof(__pyx_k_optimal), 0, 1, 0, 1}, + {&__pyx_n_s_optimize, __pyx_k_optimize, sizeof(__pyx_k_optimize), 0, 0, 1, 1}, + {&__pyx_n_s_origcopy, __pyx_k_origcopy, sizeof(__pyx_k_origcopy), 0, 0, 1, 1}, + {&__pyx_n_s_original, __pyx_k_original, sizeof(__pyx_k_original), 0, 0, 1, 1}, + {&__pyx_kp_u_origprob_sol, __pyx_k_origprob_sol, sizeof(__pyx_k_origprob_sol), 0, 1, 0, 0}, + {&__pyx_kp_u_origprob_stats, __pyx_k_origprob_stats, sizeof(__pyx_k_origprob_stats), 0, 1, 0, 0}, + {&__pyx_n_s_orthofunc, __pyx_k_orthofunc, sizeof(__pyx_k_orthofunc), 0, 0, 1, 1}, + {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1}, + {&__pyx_n_s_os_path, __pyx_k_os_path, sizeof(__pyx_k_os_path), 0, 0, 1, 1}, + {&__pyx_n_s_other, __pyx_k_other, sizeof(__pyx_k_other), 0, 0, 1, 1}, + {&__pyx_n_s_paraemphasis, __pyx_k_paraemphasis, sizeof(__pyx_k_paraemphasis), 0, 0, 1, 1}, + {&__pyx_n_s_param, __pyx_k_param, sizeof(__pyx_k_param), 0, 0, 1, 1}, + {&__pyx_kp_u_param_set, __pyx_k_param_set, sizeof(__pyx_k_param_set), 0, 1, 0, 0}, + {&__pyx_n_s_params, __pyx_k_params, sizeof(__pyx_k_params), 0, 0, 1, 1}, + {&__pyx_n_s_paramtype, __pyx_k_paramtype, sizeof(__pyx_k_paramtype), 0, 0, 1, 1}, + {&__pyx_n_s_partial, __pyx_k_partial, sizeof(__pyx_k_partial), 0, 0, 1, 1}, + {&__pyx_n_s_partialsolution, __pyx_k_partialsolution, sizeof(__pyx_k_partialsolution), 0, 0, 1, 1}, + {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1}, + {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, + {&__pyx_n_s_plus, __pyx_k_plus, sizeof(__pyx_k_plus), 0, 0, 1, 1}, + {&__pyx_n_s_pos, __pyx_k_pos, sizeof(__pyx_k_pos), 0, 0, 1, 1}, + {&__pyx_n_s_power, __pyx_k_power, sizeof(__pyx_k_power), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_presol, __pyx_k_presol, sizeof(__pyx_k_presol), 0, 0, 1, 1}, + {&__pyx_n_s_presolexec, __pyx_k_presolexec, sizeof(__pyx_k_presolexec), 0, 0, 1, 1}, + {&__pyx_n_s_presolexit, __pyx_k_presolexit, sizeof(__pyx_k_presolexit), 0, 0, 1, 1}, + {&__pyx_n_s_presolexitpre, __pyx_k_presolexitpre, sizeof(__pyx_k_presolexitpre), 0, 0, 1, 1}, + {&__pyx_n_s_presolfree, __pyx_k_presolfree, sizeof(__pyx_k_presolfree), 0, 0, 1, 1}, + {&__pyx_n_s_presolinit, __pyx_k_presolinit, sizeof(__pyx_k_presolinit), 0, 0, 1, 1}, + {&__pyx_n_s_presolinitpre, __pyx_k_presolinitpre, sizeof(__pyx_k_presolinitpre), 0, 0, 1, 1}, + {&__pyx_n_s_presolmaxrounds, __pyx_k_presolmaxrounds, sizeof(__pyx_k_presolmaxrounds), 0, 0, 1, 1}, + {&__pyx_n_s_presolpriority, __pyx_k_presolpriority, sizeof(__pyx_k_presolpriority), 0, 0, 1, 1}, + {&__pyx_n_s_presoltiming, __pyx_k_presoltiming, sizeof(__pyx_k_presoltiming), 0, 0, 1, 1}, + {&__pyx_n_s_presolve, __pyx_k_presolve, sizeof(__pyx_k_presolve), 0, 0, 1, 1}, + {&__pyx_n_s_pretendroot, __pyx_k_pretendroot, sizeof(__pyx_k_pretendroot), 0, 0, 1, 1}, + {&__pyx_n_s_pricedVar, __pyx_k_pricedVar, sizeof(__pyx_k_pricedVar), 0, 0, 1, 1}, + {&__pyx_n_s_pricedVarScore, __pyx_k_pricedVarScore, sizeof(__pyx_k_pricedVarScore), 0, 0, 1, 1}, + {&__pyx_n_s_pricer, __pyx_k_pricer, sizeof(__pyx_k_pricer), 0, 0, 1, 1}, + {&__pyx_n_s_pricerexit, __pyx_k_pricerexit, sizeof(__pyx_k_pricerexit), 0, 0, 1, 1}, + {&__pyx_n_s_pricerexitsol, __pyx_k_pricerexitsol, sizeof(__pyx_k_pricerexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_pricerfarkas, __pyx_k_pricerfarkas, sizeof(__pyx_k_pricerfarkas), 0, 0, 1, 1}, + {&__pyx_kp_u_pricerfarkas_is_a_fundamental_ca, __pyx_k_pricerfarkas_is_a_fundamental_ca, sizeof(__pyx_k_pricerfarkas_is_a_fundamental_ca), 0, 1, 0, 0}, + {&__pyx_n_s_pricerfree, __pyx_k_pricerfree, sizeof(__pyx_k_pricerfree), 0, 0, 1, 1}, + {&__pyx_n_s_pricerinit, __pyx_k_pricerinit, sizeof(__pyx_k_pricerinit), 0, 0, 1, 1}, + {&__pyx_n_s_pricerinitsol, __pyx_k_pricerinitsol, sizeof(__pyx_k_pricerinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_pricerredcost, __pyx_k_pricerredcost, sizeof(__pyx_k_pricerredcost), 0, 0, 1, 1}, + {&__pyx_kp_u_pricerredcost_is_a_fundamental_c, __pyx_k_pricerredcost_is_a_fundamental_c, sizeof(__pyx_k_pricerredcost_is_a_fundamental_c), 0, 1, 0, 0}, + {&__pyx_n_u_primallimit, __pyx_k_primallimit, sizeof(__pyx_k_primallimit), 0, 1, 0, 1}, + {&__pyx_n_s_primalsol, __pyx_k_primalsol, sizeof(__pyx_k_primalsol), 0, 0, 1, 1}, + {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1}, + {&__pyx_n_s_printBestSol, __pyx_k_printBestSol, sizeof(__pyx_k_printBestSol), 0, 0, 1, 1}, + {&__pyx_n_s_printCons, __pyx_k_printCons, sizeof(__pyx_k_printCons), 0, 0, 1, 1}, + {&__pyx_n_s_printExternalCodeVersions, __pyx_k_printExternalCodeVersions, sizeof(__pyx_k_printExternalCodeVersions), 0, 0, 1, 1}, + {&__pyx_n_s_printNlRow, __pyx_k_printNlRow, sizeof(__pyx_k_printNlRow), 0, 0, 1, 1}, + {&__pyx_n_s_printRow, __pyx_k_printRow, sizeof(__pyx_k_printRow), 0, 0, 1, 1}, + {&__pyx_n_s_printSol, __pyx_k_printSol, sizeof(__pyx_k_printSol), 0, 0, 1, 1}, + {&__pyx_n_s_printStatistics, __pyx_k_printStatistics, sizeof(__pyx_k_printStatistics), 0, 0, 1, 1}, + {&__pyx_n_s_printVersion, __pyx_k_printVersion, sizeof(__pyx_k_printVersion), 0, 0, 1, 1}, + {&__pyx_n_s_print_memory_in_use, __pyx_k_print_memory_in_use, sizeof(__pyx_k_print_memory_in_use), 0, 0, 1, 1}, + {&__pyx_n_s_printreason, __pyx_k_printreason, sizeof(__pyx_k_printreason), 0, 0, 1, 1}, + {&__pyx_n_s_priority, __pyx_k_priority, sizeof(__pyx_k_priority), 0, 0, 1, 1}, + {&__pyx_n_s_probingdepth, __pyx_k_probingdepth, sizeof(__pyx_k_probingdepth), 0, 0, 1, 1}, + {&__pyx_n_s_problemName, __pyx_k_problemName, sizeof(__pyx_k_problemName), 0, 0, 1, 1}, + {&__pyx_n_s_probnumber, __pyx_k_probnumber, sizeof(__pyx_k_probnumber), 0, 0, 1, 1}, + {&__pyx_n_s_prod, __pyx_k_prod, sizeof(__pyx_k_prod), 0, 0, 1, 1}, + {&__pyx_n_u_prod, __pyx_k_prod, sizeof(__pyx_k_prod), 0, 1, 0, 1}, + {&__pyx_n_s_prodexpr, __pyx_k_prodexpr, sizeof(__pyx_k_prodexpr), 0, 0, 1, 1}, + {&__pyx_n_s_prop, __pyx_k_prop, sizeof(__pyx_k_prop), 0, 0, 1, 1}, + {&__pyx_n_s_propagate, __pyx_k_propagate, sizeof(__pyx_k_propagate), 0, 0, 1, 1}, + {&__pyx_n_u_propagate, __pyx_k_propagate, sizeof(__pyx_k_propagate), 0, 1, 0, 1}, + {&__pyx_n_s_propagateProbing, __pyx_k_propagateProbing, sizeof(__pyx_k_propagateProbing), 0, 0, 1, 1}, + {&__pyx_kp_u_propagating_maxrounds, __pyx_k_propagating_maxrounds, sizeof(__pyx_k_propagating_maxrounds), 0, 1, 0, 0}, + {&__pyx_kp_u_propagating_maxroundsroot, __pyx_k_propagating_maxroundsroot, sizeof(__pyx_k_propagating_maxroundsroot), 0, 1, 0, 0}, + {&__pyx_n_s_propexec, __pyx_k_propexec, sizeof(__pyx_k_propexec), 0, 0, 1, 1}, + {&__pyx_n_s_propexit, __pyx_k_propexit, sizeof(__pyx_k_propexit), 0, 0, 1, 1}, + {&__pyx_n_s_propexitpre, __pyx_k_propexitpre, sizeof(__pyx_k_propexitpre), 0, 0, 1, 1}, + {&__pyx_n_s_propexitsol, __pyx_k_propexitsol, sizeof(__pyx_k_propexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_propfree, __pyx_k_propfree, sizeof(__pyx_k_propfree), 0, 0, 1, 1}, + {&__pyx_n_s_propfreq, __pyx_k_propfreq, sizeof(__pyx_k_propfreq), 0, 0, 1, 1}, + {&__pyx_n_s_propinit, __pyx_k_propinit, sizeof(__pyx_k_propinit), 0, 0, 1, 1}, + {&__pyx_n_s_propinitpre, __pyx_k_propinitpre, sizeof(__pyx_k_propinitpre), 0, 0, 1, 1}, + {&__pyx_n_s_propinitsol, __pyx_k_propinitsol, sizeof(__pyx_k_propinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_proppresol, __pyx_k_proppresol, sizeof(__pyx_k_proppresol), 0, 0, 1, 1}, + {&__pyx_n_s_propresprop, __pyx_k_propresprop, sizeof(__pyx_k_propresprop), 0, 0, 1, 1}, + {&__pyx_n_s_proptiming, __pyx_k_proptiming, sizeof(__pyx_k_proptiming), 0, 0, 1, 1}, + {&__pyx_n_s_proxy, __pyx_k_proxy, sizeof(__pyx_k_proxy), 0, 0, 1, 1}, + {&__pyx_n_s_pseudocands, __pyx_k_pseudocands, sizeof(__pyx_k_pseudocands), 0, 0, 1, 1}, + {&__pyx_n_s_ptr, __pyx_k_ptr, sizeof(__pyx_k_ptr), 0, 0, 1, 1}, + {&__pyx_n_s_ptrtuple, __pyx_k_ptrtuple, sizeof(__pyx_k_ptrtuple), 0, 0, 1, 1}, + {&__pyx_n_u_ptrtuple, __pyx_k_ptrtuple, sizeof(__pyx_k_ptrtuple), 0, 1, 0, 1}, + {&__pyx_n_s_pyCons, __pyx_k_pyCons, sizeof(__pyx_k_pyCons), 0, 0, 1, 1}, + {&__pyx_n_s_pyVar, __pyx_k_pyVar, sizeof(__pyx_k_pyVar), 0, 0, 1, 1}, + {&__pyx_n_s_py_boundtypes, __pyx_k_py_boundtypes, sizeof(__pyx_k_py_boundtypes), 0, 0, 1, 1}, + {&__pyx_n_s_py_branchbounds, __pyx_k_py_branchbounds, sizeof(__pyx_k_py_branchbounds), 0, 0, 1, 1}, + {&__pyx_n_s_py_variables, __pyx_k_py_variables, sizeof(__pyx_k_py_variables), 0, 0, 1, 1}, + {&__pyx_n_s_pycons, __pyx_k_pycons, sizeof(__pyx_k_pycons), 0, 0, 1, 1}, + {&__pyx_n_s_pycons_initial, __pyx_k_pycons_initial, sizeof(__pyx_k_pycons_initial), 0, 0, 1, 1}, + {&__pyx_n_s_pyscipopt_scip, __pyx_k_pyscipopt_scip, sizeof(__pyx_k_pyscipopt_scip), 0, 0, 1, 1}, + {&__pyx_kp_u_python_error_in_benderscreatesub, __pyx_k_python_error_in_benderscreatesub, sizeof(__pyx_k_python_error_in_benderscreatesub), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_benderscutexec_t, __pyx_k_python_error_in_benderscutexec_t, sizeof(__pyx_k_python_error_in_benderscutexec_t), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_bendersgetvar_th, __pyx_k_python_error_in_bendersgetvar_th, sizeof(__pyx_k_python_error_in_bendersgetvar_th), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_conscheck_this_m, __pyx_k_python_error_in_conscheck_this_m, sizeof(__pyx_k_python_error_in_conscheck_this_m), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_consenfolp_this, __pyx_k_python_error_in_consenfolp_this, sizeof(__pyx_k_python_error_in_consenfolp_this), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_consenfops_this, __pyx_k_python_error_in_consenfops_this, sizeof(__pyx_k_python_error_in_consenfops_this), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_consenforelax_th, __pyx_k_python_error_in_consenforelax_th, sizeof(__pyx_k_python_error_in_consenforelax_th), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_conslock_this_me, __pyx_k_python_error_in_conslock_this_me, sizeof(__pyx_k_python_error_in_conslock_this_me), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_eventexec_this_m, __pyx_k_python_error_in_eventexec_this_m, sizeof(__pyx_k_python_error_in_eventexec_this_m), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_heurexec_this_me, __pyx_k_python_error_in_heurexec_this_me, sizeof(__pyx_k_python_error_in_heurexec_this_me), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_presolexec_this, __pyx_k_python_error_in_presolexec_this, sizeof(__pyx_k_python_error_in_presolexec_this), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_propexec_this_me, __pyx_k_python_error_in_propexec_this_me, sizeof(__pyx_k_python_error_in_propexec_this_me), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_propresprop_this, __pyx_k_python_error_in_propresprop_this, sizeof(__pyx_k_python_error_in_propresprop_this), 0, 1, 0, 0}, + {&__pyx_kp_u_python_error_in_relaxexec_this_m, __pyx_k_python_error_in_relaxexec_this_m, sizeof(__pyx_k_python_error_in_relaxexec_this_m), 0, 1, 0, 0}, + {&__pyx_n_s_pyvar, __pyx_k_pyvar, sizeof(__pyx_k_pyvar), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Benderscut, __pyx_k_pyx_unpickle_Benderscut, sizeof(__pyx_k_pyx_unpickle_Benderscut), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Branchrule, __pyx_k_pyx_unpickle_Branchrule, sizeof(__pyx_k_pyx_unpickle_Branchrule), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Conshdlr, __pyx_k_pyx_unpickle_Conshdlr, sizeof(__pyx_k_pyx_unpickle_Conshdlr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Constant, __pyx_k_pyx_unpickle_Constant, sizeof(__pyx_k_pyx_unpickle_Constant), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Cutsel, __pyx_k_pyx_unpickle_Cutsel, sizeof(__pyx_k_pyx_unpickle_Cutsel), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Eventhdlr, __pyx_k_pyx_unpickle_Eventhdlr, sizeof(__pyx_k_pyx_unpickle_Eventhdlr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Expr, __pyx_k_pyx_unpickle_Expr, sizeof(__pyx_k_pyx_unpickle_Expr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_ExprCons, __pyx_k_pyx_unpickle_ExprCons, sizeof(__pyx_k_pyx_unpickle_ExprCons), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_GenExpr, __pyx_k_pyx_unpickle_GenExpr, sizeof(__pyx_k_pyx_unpickle_GenExpr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Heur, __pyx_k_pyx_unpickle_Heur, sizeof(__pyx_k_pyx_unpickle_Heur), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Nodesel, __pyx_k_pyx_unpickle_Nodesel, sizeof(__pyx_k_pyx_unpickle_Nodesel), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN, __pyx_k_pyx_unpickle_PY_SCIP_BENDERSEN, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_BENDERSEN), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR, __pyx_k_pyx_unpickle_PY_SCIP_BRANCHDIR, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_BRANCHDIR), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE, __pyx_k_pyx_unpickle_PY_SCIP_EVENTTYPE, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_EVENTTYPE), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN, __pyx_k_pyx_unpickle_PY_SCIP_HEURTIMIN, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_HEURTIMIN), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT, __pyx_k_pyx_unpickle_PY_SCIP_LPSOLSTAT, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_LPSOLSTAT), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE, __pyx_k_pyx_unpickle_PY_SCIP_NODETYPE, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_NODETYPE), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH, __pyx_k_pyx_unpickle_PY_SCIP_PARAMEMPH, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_PARAMEMPH), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT, __pyx_k_pyx_unpickle_PY_SCIP_PARAMSETT, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_PARAMSETT), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM, __pyx_k_pyx_unpickle_PY_SCIP_PRESOLTIM, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_PRESOLTIM), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN, __pyx_k_pyx_unpickle_PY_SCIP_PROPTIMIN, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_PROPTIMIN), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_RESULT, __pyx_k_pyx_unpickle_PY_SCIP_RESULT, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_RESULT), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN, __pyx_k_pyx_unpickle_PY_SCIP_ROWORIGIN, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_ROWORIGIN), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_STAGE, __pyx_k_pyx_unpickle_PY_SCIP_STAGE, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_STAGE), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PY_SCIP_STATUS, __pyx_k_pyx_unpickle_PY_SCIP_STATUS, sizeof(__pyx_k_pyx_unpickle_PY_SCIP_STATUS), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_PowExpr, __pyx_k_pyx_unpickle_PowExpr, sizeof(__pyx_k_pyx_unpickle_PowExpr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Presol, __pyx_k_pyx_unpickle_Presol, sizeof(__pyx_k_pyx_unpickle_Presol), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Pricer, __pyx_k_pyx_unpickle_Pricer, sizeof(__pyx_k_pyx_unpickle_Pricer), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_ProdExpr, __pyx_k_pyx_unpickle_ProdExpr, sizeof(__pyx_k_pyx_unpickle_ProdExpr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Prop, __pyx_k_pyx_unpickle_Prop, sizeof(__pyx_k_pyx_unpickle_Prop), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Reader, __pyx_k_pyx_unpickle_Reader, sizeof(__pyx_k_pyx_unpickle_Reader), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Relax, __pyx_k_pyx_unpickle_Relax, sizeof(__pyx_k_pyx_unpickle_Relax), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_Sepa, __pyx_k_pyx_unpickle_Sepa, sizeof(__pyx_k_pyx_unpickle_Sepa), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_SumExpr, __pyx_k_pyx_unpickle_SumExpr, sizeof(__pyx_k_pyx_unpickle_SumExpr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_UnaryExpr, __pyx_k_pyx_unpickle_UnaryExpr, sizeof(__pyx_k_pyx_unpickle_UnaryExpr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_unpickle_VarExpr, __pyx_k_pyx_unpickle_VarExpr, sizeof(__pyx_k_pyx_unpickle_VarExpr), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_quadcons, __pyx_k_quadcons, sizeof(__pyx_k_quadcons), 0, 0, 1, 1}, + {&__pyx_n_u_quadratic, __pyx_k_quadratic, sizeof(__pyx_k_quadratic), 0, 1, 0, 1}, + {&__pyx_n_s_quadterms, __pyx_k_quadterms, sizeof(__pyx_k_quadterms), 0, 0, 1, 1}, + {&__pyx_n_s_quality, __pyx_k_quality, sizeof(__pyx_k_quality), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_quickprod, __pyx_k_quickprod, sizeof(__pyx_k_quickprod), 0, 0, 1, 1}, + {&__pyx_n_s_quicksum, __pyx_k_quicksum, sizeof(__pyx_k_quicksum), 0, 0, 1, 1}, + {&__pyx_n_s_quiet, __pyx_k_quiet, sizeof(__pyx_k_quiet), 0, 0, 1, 1}, + {&__pyx_n_s_raise_error, __pyx_k_raise_error, sizeof(__pyx_k_raise_error), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_ray, __pyx_k_ray, sizeof(__pyx_k_ray), 0, 0, 1, 1}, + {&__pyx_n_s_rc, __pyx_k_rc, sizeof(__pyx_k_rc), 0, 0, 1, 1}, + {&__pyx_n_s_readLP, __pyx_k_readLP, sizeof(__pyx_k_readLP), 0, 0, 1, 1}, + {&__pyx_n_s_readParams, __pyx_k_readParams, sizeof(__pyx_k_readParams), 0, 0, 1, 1}, + {&__pyx_n_s_readProblem, __pyx_k_readProblem, sizeof(__pyx_k_readProblem), 0, 0, 1, 1}, + {&__pyx_n_s_readSol, __pyx_k_readSol, sizeof(__pyx_k_readSol), 0, 0, 1, 1}, + {&__pyx_n_s_readSolFile, __pyx_k_readSolFile, sizeof(__pyx_k_readSolFile), 0, 0, 1, 1}, + {&__pyx_n_s_reader, __pyx_k_reader, sizeof(__pyx_k_reader), 0, 0, 1, 1}, + {&__pyx_n_s_readerfree, __pyx_k_readerfree, sizeof(__pyx_k_readerfree), 0, 0, 1, 1}, + {&__pyx_n_s_readerread, __pyx_k_readerread, sizeof(__pyx_k_readerread), 0, 0, 1, 1}, + {&__pyx_n_s_readerwrite, __pyx_k_readerwrite, sizeof(__pyx_k_readerwrite), 0, 0, 1, 1}, + {&__pyx_n_s_redcost, __pyx_k_redcost, sizeof(__pyx_k_redcost), 0, 0, 1, 1}, + {&__pyx_n_s_redirectOutput, __pyx_k_redirectOutput, sizeof(__pyx_k_redirectOutput), 0, 0, 1, 1}, + {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, + {&__pyx_n_s_relax, __pyx_k_relax, sizeof(__pyx_k_relax), 0, 0, 1, 1}, + {&__pyx_n_s_relaxcons, __pyx_k_relaxcons, sizeof(__pyx_k_relaxcons), 0, 0, 1, 1}, + {&__pyx_n_s_relaxedbd, __pyx_k_relaxedbd, sizeof(__pyx_k_relaxedbd), 0, 0, 1, 1}, + {&__pyx_n_s_relaxexec, __pyx_k_relaxexec, sizeof(__pyx_k_relaxexec), 0, 0, 1, 1}, + {&__pyx_kp_u_relaxexec_must_return_a_dictiona, __pyx_k_relaxexec_must_return_a_dictiona, sizeof(__pyx_k_relaxexec_must_return_a_dictiona), 0, 1, 0, 0}, + {&__pyx_n_s_relaxexit, __pyx_k_relaxexit, sizeof(__pyx_k_relaxexit), 0, 0, 1, 1}, + {&__pyx_n_s_relaxexitsol, __pyx_k_relaxexitsol, sizeof(__pyx_k_relaxexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_relaxfree, __pyx_k_relaxfree, sizeof(__pyx_k_relaxfree), 0, 0, 1, 1}, + {&__pyx_n_s_relaxinit, __pyx_k_relaxinit, sizeof(__pyx_k_relaxinit), 0, 0, 1, 1}, + {&__pyx_n_s_relaxinitsol, __pyx_k_relaxinitsol, sizeof(__pyx_k_relaxinitsol), 0, 0, 1, 1}, + {&__pyx_n_s_releaseRow, __pyx_k_releaseRow, sizeof(__pyx_k_releaseRow), 0, 0, 1, 1}, + {&__pyx_n_s_removable, __pyx_k_removable, sizeof(__pyx_k_removable), 0, 0, 1, 1}, + {&__pyx_n_u_removable, __pyx_k_removable, sizeof(__pyx_k_removable), 0, 1, 0, 1}, + {&__pyx_n_s_repeat, __pyx_k_repeat, sizeof(__pyx_k_repeat), 0, 0, 1, 1}, + {&__pyx_n_s_repr, __pyx_k_repr, sizeof(__pyx_k_repr), 0, 0, 1, 1}, + {&__pyx_n_s_repr___locals_lambda, __pyx_k_repr___locals_lambda, sizeof(__pyx_k_repr___locals_lambda), 0, 0, 1, 1}, + {&__pyx_n_s_repropagateNode, __pyx_k_repropagateNode, sizeof(__pyx_k_repropagateNode), 0, 0, 1, 1}, + {&__pyx_n_s_resVar, __pyx_k_resVar, sizeof(__pyx_k_resVar), 0, 0, 1, 1}, + {&__pyx_n_s_resetParam, __pyx_k_resetParam, sizeof(__pyx_k_resetParam), 0, 0, 1, 1}, + {&__pyx_n_s_resetParams, __pyx_k_resetParams, sizeof(__pyx_k_resetParams), 0, 0, 1, 1}, + {&__pyx_n_s_restart, __pyx_k_restart, sizeof(__pyx_k_restart), 0, 0, 1, 1}, + {&__pyx_n_s_restartSolve, __pyx_k_restartSolve, sizeof(__pyx_k_restartSolve), 0, 0, 1, 1}, + {&__pyx_n_u_restartlimit, __pyx_k_restartlimit, sizeof(__pyx_k_restartlimit), 0, 1, 0, 1}, + {&__pyx_n_s_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 0, 1, 1}, + {&__pyx_n_u_result, __pyx_k_result, sizeof(__pyx_k_result), 0, 1, 0, 1}, + {&__pyx_n_s_result_dict, __pyx_k_result_dict, sizeof(__pyx_k_result_dict), 0, 0, 1, 1}, + {&__pyx_n_s_resvar, __pyx_k_resvar, sizeof(__pyx_k_resvar), 0, 0, 1, 1}, + {&__pyx_n_s_retcode, __pyx_k_retcode, sizeof(__pyx_k_retcode), 0, 0, 1, 1}, + {&__pyx_n_s_rhs, __pyx_k_rhs, sizeof(__pyx_k_rhs), 0, 0, 1, 1}, + {&__pyx_n_u_rhs, __pyx_k_rhs, sizeof(__pyx_k_rhs), 0, 1, 0, 1}, + {&__pyx_n_s_rhs_2, __pyx_k_rhs_2, sizeof(__pyx_k_rhs_2), 0, 0, 1, 1}, + {&__pyx_n_s_rhss, __pyx_k_rhss, sizeof(__pyx_k_rhss), 0, 0, 1, 1}, + {&__pyx_n_s_rhsslack, __pyx_k_rhsslack, sizeof(__pyx_k_rhsslack), 0, 0, 1, 1}, + {&__pyx_n_s_rhsvar, __pyx_k_rhsvar, sizeof(__pyx_k_rhsvar), 0, 0, 1, 1}, + {&__pyx_n_s_root, __pyx_k_root, sizeof(__pyx_k_root), 0, 0, 1, 1}, + {&__pyx_n_s_row, __pyx_k_row, sizeof(__pyx_k_row), 0, 0, 1, 1}, + {&__pyx_n_u_row, __pyx_k_row, sizeof(__pyx_k_row), 0, 1, 0, 1}, + {&__pyx_n_s_row1, __pyx_k_row1, sizeof(__pyx_k_row1), 0, 0, 1, 1}, + {&__pyx_n_s_row2, __pyx_k_row2, sizeof(__pyx_k_row2), 0, 0, 1, 1}, + {&__pyx_n_s_rows, __pyx_k_rows, sizeof(__pyx_k_rows), 0, 0, 1, 1}, + {&__pyx_n_s_scip_benders, __pyx_k_scip_benders, sizeof(__pyx_k_scip_benders), 0, 0, 1, 1}, + {&__pyx_n_s_scip_benderscut, __pyx_k_scip_benderscut, sizeof(__pyx_k_scip_benderscut), 0, 0, 1, 1}, + {&__pyx_n_s_scip_col, __pyx_k_scip_col, sizeof(__pyx_k_scip_col), 0, 0, 1, 1}, + {&__pyx_n_s_scip_con, __pyx_k_scip_con, sizeof(__pyx_k_scip_con), 0, 0, 1, 1}, + {&__pyx_n_s_scip_cons, __pyx_k_scip_cons, sizeof(__pyx_k_scip_cons), 0, 0, 1, 1}, + {&__pyx_n_s_scip_conshdlr, __pyx_k_scip_conshdlr, sizeof(__pyx_k_scip_conshdlr), 0, 0, 1, 1}, + {&__pyx_n_s_scip_expr, __pyx_k_scip_expr, sizeof(__pyx_k_scip_expr), 0, 0, 1, 1}, + {&__pyx_n_s_scip_pricer, __pyx_k_scip_pricer, sizeof(__pyx_k_scip_pricer), 0, 0, 1, 1}, + {&__pyx_n_s_scip_sepa, __pyx_k_scip_sepa, sizeof(__pyx_k_scip_sepa), 0, 0, 1, 1}, + {&__pyx_n_s_scip_sol, __pyx_k_scip_sol, sizeof(__pyx_k_scip_sol), 0, 0, 1, 1}, + {&__pyx_n_s_scip_subprob, __pyx_k_scip_subprob, sizeof(__pyx_k_scip_subprob), 0, 0, 1, 1}, + {&__pyx_n_s_scip_var, __pyx_k_scip_var, sizeof(__pyx_k_scip_var), 0, 0, 1, 1}, + {&__pyx_n_s_scipexprs, __pyx_k_scipexprs, sizeof(__pyx_k_scipexprs), 0, 0, 1, 1}, + {&__pyx_n_s_scipvar1, __pyx_k_scipvar1, sizeof(__pyx_k_scipvar1), 0, 0, 1, 1}, + {&__pyx_n_s_scipvar2, __pyx_k_scipvar2, sizeof(__pyx_k_scipvar2), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_kp_s_self__benders_cannot_be_converte, __pyx_k_self__benders_cannot_be_converte, sizeof(__pyx_k_self__benders_cannot_be_converte), 0, 0, 1, 0}, + {&__pyx_kp_s_self__scip_self__valid_cannot_be, __pyx_k_self__scip_self__valid_cannot_be, sizeof(__pyx_k_self__scip_self__valid_cannot_be), 0, 0, 1, 0}, + {&__pyx_kp_s_self_event_cannot_be_converted_t, __pyx_k_self_event_cannot_be_converted_t, sizeof(__pyx_k_self_event_cannot_be_converted_t), 0, 0, 1, 0}, + {&__pyx_kp_s_self_lpi_cannot_be_converted_to, __pyx_k_self_lpi_cannot_be_converted_to, sizeof(__pyx_k_self_lpi_cannot_be_converted_to), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_boundchg_cannot_be_con, __pyx_k_self_scip_boundchg_cannot_be_con, sizeof(__pyx_k_self_scip_boundchg_cannot_be_con), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_col_cannot_be_converte, __pyx_k_self_scip_col_cannot_be_converte, sizeof(__pyx_k_self_scip_col_cannot_be_converte), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_cons_cannot_be_convert, __pyx_k_self_scip_cons_cannot_be_convert, sizeof(__pyx_k_self_scip_cons_cannot_be_convert), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_domchg_cannot_be_conve, __pyx_k_self_scip_domchg_cannot_be_conve, sizeof(__pyx_k_self_scip_domchg_cannot_be_conve), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_nlrow_cannot_be_conver, __pyx_k_self_scip_nlrow_cannot_be_conver, sizeof(__pyx_k_self_scip_nlrow_cannot_be_conver), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_node_cannot_be_convert, __pyx_k_self_scip_node_cannot_be_convert, sizeof(__pyx_k_self_scip_node_cannot_be_convert), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_row_cannot_be_converte, __pyx_k_self_scip_row_cannot_be_converte, sizeof(__pyx_k_self_scip_row_cannot_be_converte), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_self_sol_cannot_be_con, __pyx_k_self_scip_self_sol_cannot_be_con, sizeof(__pyx_k_self_scip_self_sol_cannot_be_con), 0, 0, 1, 0}, + {&__pyx_kp_s_self_scip_var_cannot_be_converte, __pyx_k_self_scip_var_cannot_be_converte, sizeof(__pyx_k_self_scip_var_cannot_be_converte), 0, 0, 1, 0}, + {&__pyx_n_u_selnode, __pyx_k_selnode, sizeof(__pyx_k_selnode), 0, 1, 0, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, + {&__pyx_n_s_sense, __pyx_k_sense, sizeof(__pyx_k_sense), 0, 0, 1, 1}, + {&__pyx_n_s_sepa, __pyx_k_sepa, sizeof(__pyx_k_sepa), 0, 0, 1, 1}, + {&__pyx_n_s_sepaexeclp, __pyx_k_sepaexeclp, sizeof(__pyx_k_sepaexeclp), 0, 0, 1, 1}, + {&__pyx_n_s_sepaexecsol, __pyx_k_sepaexecsol, sizeof(__pyx_k_sepaexecsol), 0, 0, 1, 1}, + {&__pyx_n_s_sepaexit, __pyx_k_sepaexit, sizeof(__pyx_k_sepaexit), 0, 0, 1, 1}, + {&__pyx_n_s_sepaexitsol, __pyx_k_sepaexitsol, sizeof(__pyx_k_sepaexitsol), 0, 0, 1, 1}, + {&__pyx_n_s_sepafree, __pyx_k_sepafree, sizeof(__pyx_k_sepafree), 0, 0, 1, 1}, + {&__pyx_n_s_sepafreq, __pyx_k_sepafreq, sizeof(__pyx_k_sepafreq), 0, 0, 1, 1}, + {&__pyx_n_s_sepainit, __pyx_k_sepainit, sizeof(__pyx_k_sepainit), 0, 0, 1, 1}, + {&__pyx_n_s_sepainitsol, __pyx_k_sepainitsol, sizeof(__pyx_k_sepainitsol), 0, 0, 1, 1}, + {&__pyx_n_s_sepapriority, __pyx_k_sepapriority, sizeof(__pyx_k_sepapriority), 0, 0, 1, 1}, + {&__pyx_n_s_separate, __pyx_k_separate, sizeof(__pyx_k_separate), 0, 0, 1, 1}, + {&__pyx_n_u_separate, __pyx_k_separate, sizeof(__pyx_k_separate), 0, 1, 0, 1}, + {&__pyx_n_s_separateSol, __pyx_k_separateSol, sizeof(__pyx_k_separateSol), 0, 0, 1, 1}, + {&__pyx_n_s_setBendersSubproblemIsConvex, __pyx_k_setBendersSubproblemIsConvex, sizeof(__pyx_k_setBendersSubproblemIsConvex), 0, 0, 1, 1}, + {&__pyx_n_s_setBoolParam, __pyx_k_setBoolParam, sizeof(__pyx_k_setBoolParam), 0, 0, 1, 1}, + {&__pyx_n_s_setCharParam, __pyx_k_setCharParam, sizeof(__pyx_k_setCharParam), 0, 0, 1, 1}, + {&__pyx_n_s_setCheck, __pyx_k_setCheck, sizeof(__pyx_k_setCheck), 0, 0, 1, 1}, + {&__pyx_n_s_setEmphasis, __pyx_k_setEmphasis, sizeof(__pyx_k_setEmphasis), 0, 0, 1, 1}, + {&__pyx_n_s_setEnforced, __pyx_k_setEnforced, sizeof(__pyx_k_setEnforced), 0, 0, 1, 1}, + {&__pyx_n_s_setHeuristics, __pyx_k_setHeuristics, sizeof(__pyx_k_setHeuristics), 0, 0, 1, 1}, + {&__pyx_n_s_setInitial, __pyx_k_setInitial, sizeof(__pyx_k_setInitial), 0, 0, 1, 1}, + {&__pyx_n_s_setIntParam, __pyx_k_setIntParam, sizeof(__pyx_k_setIntParam), 0, 0, 1, 1}, + {&__pyx_n_s_setLogfile, __pyx_k_setLogfile, sizeof(__pyx_k_setLogfile), 0, 0, 1, 1}, + {&__pyx_n_s_setLongintParam, __pyx_k_setLongintParam, sizeof(__pyx_k_setLongintParam), 0, 0, 1, 1}, + {&__pyx_n_s_setMaximize, __pyx_k_setMaximize, sizeof(__pyx_k_setMaximize), 0, 0, 1, 1}, + {&__pyx_n_s_setMinimize, __pyx_k_setMinimize, sizeof(__pyx_k_setMinimize), 0, 0, 1, 1}, + {&__pyx_n_s_setObjIntegral, __pyx_k_setObjIntegral, sizeof(__pyx_k_setObjIntegral), 0, 0, 1, 1}, + {&__pyx_n_s_setObjective, __pyx_k_setObjective, sizeof(__pyx_k_setObjective), 0, 0, 1, 1}, + {&__pyx_n_s_setObjlimit, __pyx_k_setObjlimit, sizeof(__pyx_k_setObjlimit), 0, 0, 1, 1}, + {&__pyx_n_s_setParam, __pyx_k_setParam, sizeof(__pyx_k_setParam), 0, 0, 1, 1}, + {&__pyx_n_s_setParams, __pyx_k_setParams, sizeof(__pyx_k_setParams), 0, 0, 1, 1}, + {&__pyx_n_s_setParamsCountsols, __pyx_k_setParamsCountsols, sizeof(__pyx_k_setParamsCountsols), 0, 0, 1, 1}, + {&__pyx_n_s_setPresolve, __pyx_k_setPresolve, sizeof(__pyx_k_setPresolve), 0, 0, 1, 1}, + {&__pyx_n_s_setProbName, __pyx_k_setProbName, sizeof(__pyx_k_setProbName), 0, 0, 1, 1}, + {&__pyx_n_s_setRealParam, __pyx_k_setRealParam, sizeof(__pyx_k_setRealParam), 0, 0, 1, 1}, + {&__pyx_n_s_setRelaxSolVal, __pyx_k_setRelaxSolVal, sizeof(__pyx_k_setRelaxSolVal), 0, 0, 1, 1}, + {&__pyx_n_s_setRemovable, __pyx_k_setRemovable, sizeof(__pyx_k_setRemovable), 0, 0, 1, 1}, + {&__pyx_n_s_setSeparating, __pyx_k_setSeparating, sizeof(__pyx_k_setSeparating), 0, 0, 1, 1}, + {&__pyx_n_s_setSolVal, __pyx_k_setSolVal, sizeof(__pyx_k_setSolVal), 0, 0, 1, 1}, + {&__pyx_n_s_setStringParam, __pyx_k_setStringParam, sizeof(__pyx_k_setStringParam), 0, 0, 1, 1}, + {&__pyx_n_s_set_name, __pyx_k_set_name, sizeof(__pyx_k_set_name), 0, 0, 1, 1}, + {&__pyx_n_s_setlocale, __pyx_k_setlocale, sizeof(__pyx_k_setlocale), 0, 0, 1, 1}, + {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_setting, __pyx_k_setting, sizeof(__pyx_k_setting), 0, 0, 1, 1}, + {&__pyx_n_s_setupBendersSubproblem, __pyx_k_setupBendersSubproblem, sizeof(__pyx_k_setupBendersSubproblem), 0, 0, 1, 1}, + {&__pyx_n_s_shareaux, __pyx_k_shareaux, sizeof(__pyx_k_shareaux), 0, 0, 1, 1}, + {&__pyx_n_s_siblings, __pyx_k_siblings, sizeof(__pyx_k_siblings), 0, 0, 1, 1}, + {&__pyx_n_s_siblings_2, __pyx_k_siblings_2, sizeof(__pyx_k_siblings_2), 0, 0, 1, 1}, + {&__pyx_n_s_side, __pyx_k_side, sizeof(__pyx_k_side), 0, 0, 1, 1}, + {&__pyx_n_s_sin, __pyx_k_sin, sizeof(__pyx_k_sin), 0, 0, 1, 1}, + {&__pyx_n_u_sin, __pyx_k_sin, sizeof(__pyx_k_sin), 0, 1, 0, 1}, + {&__pyx_n_u_skipsolve, __pyx_k_skipsolve, sizeof(__pyx_k_skipsolve), 0, 1, 0, 1}, + {&__pyx_n_s_slots, __pyx_k_slots, sizeof(__pyx_k_slots), 0, 0, 1, 1}, + {&__pyx_n_s_sol, __pyx_k_sol, sizeof(__pyx_k_sol), 0, 0, 1, 1}, + {&__pyx_n_s_sol_2, __pyx_k_sol_2, sizeof(__pyx_k_sol_2), 0, 0, 1, 1}, + {&__pyx_n_s_solinfeasible, __pyx_k_solinfeasible, sizeof(__pyx_k_solinfeasible), 0, 0, 1, 1}, + {&__pyx_n_u_sollimit, __pyx_k_sollimit, sizeof(__pyx_k_sollimit), 0, 1, 0, 1}, + {&__pyx_n_s_solptr, __pyx_k_solptr, sizeof(__pyx_k_solptr), 0, 0, 1, 1}, + {&__pyx_n_s_sols, __pyx_k_sols, sizeof(__pyx_k_sols), 0, 0, 1, 1}, + {&__pyx_n_s_sols_2, __pyx_k_sols_2, sizeof(__pyx_k_sols_2), 0, 0, 1, 1}, + {&__pyx_n_s_solution, __pyx_k_solution, sizeof(__pyx_k_solution), 0, 0, 1, 1}, + {&__pyx_n_s_solutions, __pyx_k_solutions, sizeof(__pyx_k_solutions), 0, 0, 1, 1}, + {&__pyx_n_s_solve, __pyx_k_solve, sizeof(__pyx_k_solve), 0, 0, 1, 1}, + {&__pyx_n_s_solveBendersSubproblem, __pyx_k_solveBendersSubproblem, sizeof(__pyx_k_solveBendersSubproblem), 0, 0, 1, 1}, + {&__pyx_n_s_solveConcurrent, __pyx_k_solveConcurrent, sizeof(__pyx_k_solveConcurrent), 0, 0, 1, 1}, + {&__pyx_n_s_solveDiveLP, __pyx_k_solveDiveLP, sizeof(__pyx_k_solveDiveLP), 0, 0, 1, 1}, + {&__pyx_n_s_solveProbingLP, __pyx_k_solveProbingLP, sizeof(__pyx_k_solveProbingLP), 0, 0, 1, 1}, + {&__pyx_n_s_solvecip, __pyx_k_solvecip, sizeof(__pyx_k_solvecip), 0, 0, 1, 1}, + {&__pyx_n_s_sorted, __pyx_k_sorted, sizeof(__pyx_k_sorted), 0, 0, 1, 1}, + {&__pyx_n_s_sourceModel, __pyx_k_sourceModel, sizeof(__pyx_k_sourceModel), 0, 0, 1, 1}, + {&__pyx_n_s_sourceconstraint, __pyx_k_sourceconstraint, sizeof(__pyx_k_sourceconstraint), 0, 0, 1, 1}, + {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, + {&__pyx_n_s_splitext, __pyx_k_splitext, sizeof(__pyx_k_splitext), 0, 0, 1, 1}, + {&__pyx_n_s_sqrcoef, __pyx_k_sqrcoef, sizeof(__pyx_k_sqrcoef), 0, 0, 1, 1}, + {&__pyx_n_s_sqrexpr, __pyx_k_sqrexpr, sizeof(__pyx_k_sqrexpr), 0, 0, 1, 1}, + {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1}, + {&__pyx_n_u_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 1, 0, 1}, + {&__pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_k_src_pyscipopt_benders_pxi, sizeof(__pyx_k_src_pyscipopt_benders_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_benderscut_pxi, __pyx_k_src_pyscipopt_benderscut_pxi, sizeof(__pyx_k_src_pyscipopt_benderscut_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_k_src_pyscipopt_branchrule_pxi, sizeof(__pyx_k_src_pyscipopt_branchrule_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_k_src_pyscipopt_conshdlr_pxi, sizeof(__pyx_k_src_pyscipopt_conshdlr_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_cutsel_pxi, __pyx_k_src_pyscipopt_cutsel_pxi, sizeof(__pyx_k_src_pyscipopt_cutsel_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_event_pxi, __pyx_k_src_pyscipopt_event_pxi, sizeof(__pyx_k_src_pyscipopt_event_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_k_src_pyscipopt_expr_pxi, sizeof(__pyx_k_src_pyscipopt_expr_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_heuristic_pxi, __pyx_k_src_pyscipopt_heuristic_pxi, sizeof(__pyx_k_src_pyscipopt_heuristic_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_k_src_pyscipopt_lp_pxi, sizeof(__pyx_k_src_pyscipopt_lp_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_nodesel_pxi, __pyx_k_src_pyscipopt_nodesel_pxi, sizeof(__pyx_k_src_pyscipopt_nodesel_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_presol_pxi, __pyx_k_src_pyscipopt_presol_pxi, sizeof(__pyx_k_src_pyscipopt_presol_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_pricer_pxi, __pyx_k_src_pyscipopt_pricer_pxi, sizeof(__pyx_k_src_pyscipopt_pricer_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_k_src_pyscipopt_propagator_pxi, sizeof(__pyx_k_src_pyscipopt_propagator_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_reader_pxi, __pyx_k_src_pyscipopt_reader_pxi, sizeof(__pyx_k_src_pyscipopt_reader_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_relax_pxi, __pyx_k_src_pyscipopt_relax_pxi, sizeof(__pyx_k_src_pyscipopt_relax_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_k_src_pyscipopt_scip_pxi, sizeof(__pyx_k_src_pyscipopt_scip_pxi), 0, 0, 1, 0}, + {&__pyx_kp_s_src_pyscipopt_sepa_pxi, __pyx_k_src_pyscipopt_sepa_pxi, sizeof(__pyx_k_src_pyscipopt_sepa_pxi), 0, 0, 1, 0}, + {&__pyx_n_u_stallnodelimit, __pyx_k_stallnodelimit, sizeof(__pyx_k_stallnodelimit), 0, 1, 0, 1}, + {&__pyx_n_s_startDive, __pyx_k_startDive, sizeof(__pyx_k_startDive), 0, 0, 1, 1}, + {&__pyx_n_s_startProbing, __pyx_k_startProbing, sizeof(__pyx_k_startProbing), 0, 0, 1, 1}, + {&__pyx_n_s_startnconss, __pyx_k_startnconss, sizeof(__pyx_k_startnconss), 0, 0, 1, 1}, + {&__pyx_n_s_startnvars, __pyx_k_startnvars, sizeof(__pyx_k_startnvars), 0, 0, 1, 1}, + {&__pyx_n_s_stat, __pyx_k_stat, sizeof(__pyx_k_stat), 0, 0, 1, 1}, + {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, + {&__pyx_n_s_staticmethod, __pyx_k_staticmethod, sizeof(__pyx_k_staticmethod), 0, 0, 1, 1}, + {&__pyx_n_s_stderr, __pyx_k_stderr, sizeof(__pyx_k_stderr), 0, 0, 1, 1}, + {&__pyx_n_s_stdout, __pyx_k_stdout, sizeof(__pyx_k_stdout), 0, 0, 1, 1}, + {&__pyx_n_s_stdpriority, __pyx_k_stdpriority, sizeof(__pyx_k_stdpriority), 0, 0, 1, 1}, + {&__pyx_n_s_stickingatnode, __pyx_k_stickingatnode, sizeof(__pyx_k_stickingatnode), 0, 0, 1, 1}, + {&__pyx_n_u_stickingatnode, __pyx_k_stickingatnode, sizeof(__pyx_k_stickingatnode), 0, 1, 0, 1}, + {&__pyx_n_u_stopearly, __pyx_k_stopearly, sizeof(__pyx_k_stopearly), 0, 1, 0, 1}, + {&__pyx_n_s_stored, __pyx_k_stored, sizeof(__pyx_k_stored), 0, 0, 1, 1}, + {&__pyx_n_s_str_absfile, __pyx_k_str_absfile, sizeof(__pyx_k_str_absfile), 0, 0, 1, 1}, + {&__pyx_n_s_str_conversion, __pyx_k_str_conversion, sizeof(__pyx_k_str_conversion), 0, 0, 1, 1}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_subprob, __pyx_k_subprob, sizeof(__pyx_k_subprob), 0, 0, 1, 1}, + {&__pyx_n_s_subproblem, __pyx_k_subproblem, sizeof(__pyx_k_subproblem), 0, 0, 1, 1}, + {&__pyx_n_s_subproblems, __pyx_k_subproblems, sizeof(__pyx_k_subproblems), 0, 0, 1, 1}, + {&__pyx_n_s_subprobs, __pyx_k_subprobs, sizeof(__pyx_k_subprobs), 0, 0, 1, 1}, + {&__pyx_n_s_success, __pyx_k_success, sizeof(__pyx_k_success), 0, 0, 1, 1}, + {&__pyx_n_u_success, __pyx_k_success, sizeof(__pyx_k_success), 0, 1, 0, 1}, + {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, + {&__pyx_n_u_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 1, 0, 1}, + {&__pyx_n_s_sumexpr, __pyx_k_sumexpr, sizeof(__pyx_k_sumexpr), 0, 0, 1, 1}, + {&__pyx_n_s_super, __pyx_k_super, sizeof(__pyx_k_super), 0, 0, 1, 1}, + {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, + {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, + {&__pyx_n_s_take_ownership, __pyx_k_take_ownership, sizeof(__pyx_k_take_ownership), 0, 0, 1, 1}, + {&__pyx_n_u_targetcons, __pyx_k_targetcons, sizeof(__pyx_k_targetcons), 0, 1, 0, 1}, + {&__pyx_n_s_targetvalue, __pyx_k_targetvalue, sizeof(__pyx_k_targetvalue), 0, 0, 1, 1}, + {&__pyx_n_s_temp_cons, __pyx_k_temp_cons, sizeof(__pyx_k_temp_cons), 0, 0, 1, 1}, + {&__pyx_n_s_term, __pyx_k_term, sizeof(__pyx_k_term), 0, 0, 1, 1}, + {&__pyx_kp_u_term_length_must_be_1_or_2_but_i, __pyx_k_term_length_must_be_1_or_2_but_i, sizeof(__pyx_k_term_length_must_be_1_or_2_but_i), 0, 1, 0, 0}, + {&__pyx_n_s_termcoefs, __pyx_k_termcoefs, sizeof(__pyx_k_termcoefs), 0, 0, 1, 1}, + {&__pyx_n_s_termidx, __pyx_k_termidx, sizeof(__pyx_k_termidx), 0, 0, 1, 1}, + {&__pyx_n_s_termlist, __pyx_k_termlist, sizeof(__pyx_k_termlist), 0, 0, 1, 1}, + {&__pyx_n_s_terms, __pyx_k_terms, sizeof(__pyx_k_terms), 0, 0, 1, 1}, + {&__pyx_n_s_termvars, __pyx_k_termvars, sizeof(__pyx_k_termvars), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_threadsafe, __pyx_k_threadsafe, sizeof(__pyx_k_threadsafe), 0, 0, 1, 1}, + {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, + {&__pyx_n_s_tightenVarLb, __pyx_k_tightenVarLb, sizeof(__pyx_k_tightenVarLb), 0, 0, 1, 1}, + {&__pyx_n_s_tightenVarLbGlobal, __pyx_k_tightenVarLbGlobal, sizeof(__pyx_k_tightenVarLbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_tightenVarUb, __pyx_k_tightenVarUb, sizeof(__pyx_k_tightenVarUb), 0, 0, 1, 1}, + {&__pyx_n_s_tightenVarUbGlobal, __pyx_k_tightenVarUbGlobal, sizeof(__pyx_k_tightenVarUbGlobal), 0, 0, 1, 1}, + {&__pyx_n_s_tightened, __pyx_k_tightened, sizeof(__pyx_k_tightened), 0, 0, 1, 1}, + {&__pyx_n_u_timelimit, __pyx_k_timelimit, sizeof(__pyx_k_timelimit), 0, 1, 0, 1}, + {&__pyx_n_s_timing, __pyx_k_timing, sizeof(__pyx_k_timing), 0, 0, 1, 1}, + {&__pyx_n_s_timingmask, __pyx_k_timingmask, sizeof(__pyx_k_timingmask), 0, 0, 1, 1}, + {&__pyx_n_s_tmp, __pyx_k_tmp, sizeof(__pyx_k_tmp), 0, 0, 1, 1}, + {&__pyx_n_s_to_ptr, __pyx_k_to_ptr, sizeof(__pyx_k_to_ptr), 0, 0, 1, 1}, + {&__pyx_kp_u_total_number_of_solutions_found, __pyx_k_total_number_of_solutions_found, sizeof(__pyx_k_total_number_of_solutions_found), 0, 1, 0, 0}, + {&__pyx_n_u_totalnodelimit, __pyx_k_totalnodelimit, sizeof(__pyx_k_totalnodelimit), 0, 1, 0, 1}, + {&__pyx_n_s_trans, __pyx_k_trans, sizeof(__pyx_k_trans), 0, 0, 1, 1}, + {&__pyx_n_s_transcons, __pyx_k_transcons, sizeof(__pyx_k_transcons), 0, 0, 1, 1}, + {&__pyx_n_s_transformed, __pyx_k_transformed, sizeof(__pyx_k_transformed), 0, 0, 1, 1}, + {&__pyx_kp_u_transprob_sol, __pyx_k_transprob_sol, sizeof(__pyx_k_transprob_sol), 0, 1, 0, 0}, + {&__pyx_n_u_true, __pyx_k_true, sizeof(__pyx_k_true), 0, 1, 0, 1}, + {&__pyx_n_s_truediv, __pyx_k_truediv, sizeof(__pyx_k_truediv), 0, 0, 1, 1}, + {&__pyx_n_s_trySol, __pyx_k_trySol, sizeof(__pyx_k_trySol), 0, 0, 1, 1}, + {&__pyx_n_s_tvar, __pyx_k_tvar, sizeof(__pyx_k_tvar), 0, 0, 1, 1}, + {&__pyx_n_s_typing, __pyx_k_typing, sizeof(__pyx_k_typing), 0, 0, 1, 1}, + {&__pyx_n_s_ub, __pyx_k_ub, sizeof(__pyx_k_ub), 0, 0, 1, 1}, + {&__pyx_n_s_ubs, __pyx_k_ubs, sizeof(__pyx_k_ubs), 0, 0, 1, 1}, + {&__pyx_n_u_unbounded, __pyx_k_unbounded, sizeof(__pyx_k_unbounded), 0, 1, 0, 1}, + {&__pyx_n_u_unknown, __pyx_k_unknown, sizeof(__pyx_k_unknown), 0, 1, 0, 1}, + {&__pyx_kp_u_unrecognized_objective_sense, __pyx_k_unrecognized_objective_sense, sizeof(__pyx_k_unrecognized_objective_sense), 0, 1, 0, 0}, + {&__pyx_kp_u_unrecognized_optimization_sense, __pyx_k_unrecognized_optimization_sense, sizeof(__pyx_k_unrecognized_optimization_sense), 0, 1, 0, 0}, + {&__pyx_kp_u_unrecognized_variable_type, __pyx_k_unrecognized_variable_type, sizeof(__pyx_k_unrecognized_variable_type), 0, 1, 0, 0}, + {&__pyx_n_s_upchild, __pyx_k_upchild, sizeof(__pyx_k_upchild), 0, 0, 1, 1}, + {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, + {&__pyx_n_s_updateBendersLowerbounds, __pyx_k_updateBendersLowerbounds, sizeof(__pyx_k_updateBendersLowerbounds), 0, 0, 1, 1}, + {&__pyx_n_s_updateNodeLowerbound, __pyx_k_updateNodeLowerbound, sizeof(__pyx_k_updateNodeLowerbound), 0, 0, 1, 1}, + {&__pyx_n_s_upper, __pyx_k_upper, sizeof(__pyx_k_upper), 0, 0, 1, 1}, + {&__pyx_n_u_upper, __pyx_k_upper, sizeof(__pyx_k_upper), 0, 1, 0, 1}, + {&__pyx_n_s_use_setstate, __pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 0, 1, 1}, + {&__pyx_n_s_user_locale, __pyx_k_user_locale, sizeof(__pyx_k_user_locale), 0, 0, 1, 1}, + {&__pyx_n_u_userinterrupt, __pyx_k_userinterrupt, sizeof(__pyx_k_userinterrupt), 0, 1, 0, 1}, + {&__pyx_n_s_usessubscip, __pyx_k_usessubscip, sizeof(__pyx_k_usessubscip), 0, 0, 1, 1}, + {&__pyx_kp_u_utf_8, __pyx_k_utf_8, sizeof(__pyx_k_utf_8), 0, 1, 0, 0}, + {&__pyx_n_s_v, __pyx_k_v, sizeof(__pyx_k_v), 0, 0, 1, 1}, + {&__pyx_n_s_val, __pyx_k_val, sizeof(__pyx_k_val), 0, 0, 1, 1}, + {&__pyx_n_s_val1, __pyx_k_val1, sizeof(__pyx_k_val1), 0, 0, 1, 1}, + {&__pyx_n_s_val2, __pyx_k_val2, sizeof(__pyx_k_val2), 0, 0, 1, 1}, + {&__pyx_n_s_valid, __pyx_k_valid, sizeof(__pyx_k_valid), 0, 0, 1, 1}, + {&__pyx_n_s_validnode, __pyx_k_validnode, sizeof(__pyx_k_validnode), 0, 0, 1, 1}, + {&__pyx_n_s_vals, __pyx_k_vals, sizeof(__pyx_k_vals), 0, 0, 1, 1}, + {&__pyx_n_s_vals_2, __pyx_k_vals_2, sizeof(__pyx_k_vals_2), 0, 0, 1, 1}, + {&__pyx_n_s_valsdict, __pyx_k_valsdict, sizeof(__pyx_k_valsdict), 0, 0, 1, 1}, + {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, + {&__pyx_n_s_value_to_array, __pyx_k_value_to_array, sizeof(__pyx_k_value_to_array), 0, 0, 1, 1}, + {&__pyx_n_s_valuenode, __pyx_k_valuenode, sizeof(__pyx_k_valuenode), 0, 0, 1, 1}, + {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, + {&__pyx_n_s_var, __pyx_k_var, sizeof(__pyx_k_var), 0, 0, 1, 1}, + {&__pyx_n_u_var, __pyx_k_var, sizeof(__pyx_k_var), 0, 1, 0, 1}, + {&__pyx_n_s_var1, __pyx_k_var1, sizeof(__pyx_k_var1), 0, 0, 1, 1}, + {&__pyx_n_s_var2, __pyx_k_var2, sizeof(__pyx_k_var2), 0, 0, 1, 1}, + {&__pyx_n_s_var_2, __pyx_k_var_2, sizeof(__pyx_k_var_2), 0, 0, 1, 1}, + {&__pyx_n_s_var_dict, __pyx_k_var_dict, sizeof(__pyx_k_var_dict), 0, 0, 1, 1}, + {&__pyx_n_s_varexpr, __pyx_k_varexpr, sizeof(__pyx_k_varexpr), 0, 0, 1, 1}, + {&__pyx_n_s_varexprs, __pyx_k_varexprs, sizeof(__pyx_k_varexprs), 0, 0, 1, 1}, + {&__pyx_n_s_variable, __pyx_k_variable, sizeof(__pyx_k_variable), 0, 0, 1, 1}, + {&__pyx_n_s_variables, __pyx_k_variables, sizeof(__pyx_k_variables), 0, 0, 1, 1}, + {&__pyx_n_s_varidx, __pyx_k_varidx, sizeof(__pyx_k_varidx), 0, 0, 1, 1}, + {&__pyx_n_s_varindex, __pyx_k_varindex, sizeof(__pyx_k_varindex), 0, 0, 1, 1}, + {&__pyx_n_s_varpos, __pyx_k_varpos, sizeof(__pyx_k_varpos), 0, 0, 1, 1}, + {&__pyx_n_s_vars, __pyx_k_vars, sizeof(__pyx_k_vars), 0, 0, 1, 1}, + {&__pyx_n_s_vars_2, __pyx_k_vars_2, sizeof(__pyx_k_vars_2), 0, 0, 1, 1}, + {&__pyx_n_s_vars_array, __pyx_k_vars_array, sizeof(__pyx_k_vars_array), 0, 0, 1, 1}, + {&__pyx_n_s_vartuple, __pyx_k_vartuple, sizeof(__pyx_k_vartuple), 0, 0, 1, 1}, + {&__pyx_n_u_vartuple, __pyx_k_vartuple, sizeof(__pyx_k_vartuple), 0, 1, 0, 1}, + {&__pyx_n_s_vartype, __pyx_k_vartype, sizeof(__pyx_k_vartype), 0, 0, 1, 1}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, + {&__pyx_n_s_version_info, __pyx_k_version_info, sizeof(__pyx_k_version_info), 0, 0, 1, 1}, + {&__pyx_n_s_vtype, __pyx_k_vtype, sizeof(__pyx_k_vtype), 0, 0, 1, 1}, + {&__pyx_n_u_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 1, 0, 1}, + {&__pyx_n_s_warn, __pyx_k_warn, sizeof(__pyx_k_warn), 0, 0, 1, 1}, + {&__pyx_n_s_warnings, __pyx_k_warnings, sizeof(__pyx_k_warnings), 0, 0, 1, 1}, + {&__pyx_n_s_weakref, __pyx_k_weakref, sizeof(__pyx_k_weakref), 0, 0, 1, 1}, + {&__pyx_n_s_weight, __pyx_k_weight, sizeof(__pyx_k_weight), 0, 0, 1, 1}, + {&__pyx_n_s_weights, __pyx_k_weights, sizeof(__pyx_k_weights), 0, 0, 1, 1}, + {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, + {&__pyx_n_s_writeBestSol, __pyx_k_writeBestSol, sizeof(__pyx_k_writeBestSol), 0, 0, 1, 1}, + {&__pyx_n_s_writeBestTransSol, __pyx_k_writeBestTransSol, sizeof(__pyx_k_writeBestTransSol), 0, 0, 1, 1}, + {&__pyx_n_s_writeLP, __pyx_k_writeLP, sizeof(__pyx_k_writeLP), 0, 0, 1, 1}, + {&__pyx_n_s_writeName, __pyx_k_writeName, sizeof(__pyx_k_writeName), 0, 0, 1, 1}, + {&__pyx_n_s_writeParams, __pyx_k_writeParams, sizeof(__pyx_k_writeParams), 0, 0, 1, 1}, + {&__pyx_n_s_writeProblem, __pyx_k_writeProblem, sizeof(__pyx_k_writeProblem), 0, 0, 1, 1}, + {&__pyx_n_s_writeSol, __pyx_k_writeSol, sizeof(__pyx_k_writeSol), 0, 0, 1, 1}, + {&__pyx_n_s_writeStatistics, __pyx_k_writeStatistics, sizeof(__pyx_k_writeStatistics), 0, 0, 1, 1}, + {&__pyx_n_s_writeTransSol, __pyx_k_writeTransSol, sizeof(__pyx_k_writeTransSol), 0, 0, 1, 1}, + {&__pyx_n_s_write_zeros, __pyx_k_write_zeros, sizeof(__pyx_k_write_zeros), 0, 0, 1, 1}, + {&__pyx_kp_u_wrote_parameter_settings_to_file, __pyx_k_wrote_parameter_settings_to_file, sizeof(__pyx_k_wrote_parameter_settings_to_file), 0, 1, 0, 0}, + {&__pyx_kp_u_wrote_problem_to_file, __pyx_k_wrote_problem_to_file, sizeof(__pyx_k_wrote_problem_to_file), 0, 1, 0, 0}, + {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, + {&__pyx_n_u_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 1, 0, 1}, + {&__pyx_n_u_zero, __pyx_k_zero, sizeof(__pyx_k_zero), 0, 1, 0, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_staticmethod = __Pyx_GetBuiltinName(__pyx_n_s_staticmethod); if (!__pyx_builtin_staticmethod) __PYX_ERR(0, 1074, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 51, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 53, __pyx_L1_error) + __pyx_builtin_NotImplementedError = __Pyx_GetBuiltinName(__pyx_n_s_NotImplementedError); if (!__pyx_builtin_NotImplementedError) __PYX_ERR(1, 64, __pyx_L1_error) + __pyx_builtin_sorted = __Pyx_GetBuiltinName(__pyx_n_s_sorted); if (!__pyx_builtin_sorted) __PYX_ERR(1, 89, __pyx_L1_error) + __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_n_s_sum); if (!__pyx_builtin_sum) __PYX_ERR(1, 91, __pyx_L1_error) + __pyx_builtin_AssertionError = __Pyx_GetBuiltinName(__pyx_n_s_AssertionError); if (!__pyx_builtin_AssertionError) __PYX_ERR(1, 139, __pyx_L1_error) + __pyx_builtin_StopIteration = __Pyx_GetBuiltinName(__pyx_n_s_StopIteration); if (!__pyx_builtin_StopIteration) __PYX_ERR(1, 165, __pyx_L1_error) + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(1, 249, __pyx_L1_error) + __pyx_builtin_max = __Pyx_GetBuiltinName(__pyx_n_s_max); if (!__pyx_builtin_max) __PYX_ERR(1, 284, __pyx_L1_error) + __pyx_builtin_ZeroDivisionError = __Pyx_GetBuiltinName(__pyx_n_s_ZeroDivisionError); if (!__pyx_builtin_ZeroDivisionError) __PYX_ERR(1, 525, __pyx_L1_error) + __pyx_builtin_map = __Pyx_GetBuiltinName(__pyx_n_s_map); if (!__pyx_builtin_map) __PYX_ERR(1, 573, __pyx_L1_error) + __pyx_builtin_Warning = __Pyx_GetBuiltinName(__pyx_n_s_Warning); if (!__pyx_builtin_Warning) __PYX_ERR(2, 20, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(2, 80, __pyx_L1_error) + __pyx_builtin_print = __Pyx_GetBuiltinName(__pyx_n_s_print); if (!__pyx_builtin_print) __PYX_ERR(3, 38, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(0, 266, __pyx_L1_error) + __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) __PYX_ERR(0, 268, __pyx_L1_error) + __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 289, __pyx_L1_error) + __pyx_builtin_LookupError = __Pyx_GetBuiltinName(__pyx_n_s_LookupError); if (!__pyx_builtin_LookupError) __PYX_ERR(0, 291, __pyx_L1_error) + __pyx_builtin_open = __Pyx_GetBuiltinName(__pyx_n_s_open); if (!__pyx_builtin_open) __PYX_ERR(0, 4612, __pyx_L1_error) + __pyx_builtin_chr = __Pyx_GetBuiltinName(__pyx_n_s_chr); if (!__pyx_builtin_chr) __PYX_ERR(0, 5260, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "src/pyscipopt/expr.pxi":80 + * raise NotImplementedError + * else: + * raise NotImplementedError("Can only support constraints with '<=', '>=', or '=='.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_Can_only_support_constraints_wit); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "src/pyscipopt/expr.pxi":321 + * if op == 1: # <= + * if not self._rhs is None: + * raise TypeError('ExprCons already has upper bound') # <<<<<<<<<<<<<< + * assert self._rhs is None + * assert not self._lhs is None + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_ExprCons_already_has_upper_bound); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 321, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "src/pyscipopt/expr.pxi":326 + * + * if not _is_number(other): + * raise TypeError('Ranged ExprCons is not well defined!') # <<<<<<<<<<<<<< + * + * return ExprCons(self.expr, lhs=self._lhs, rhs=float(other)) + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Ranged_ExprCons_is_not_well_defi); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "src/pyscipopt/expr.pxi":331 + * elif op == 5: # >= + * if not self._lhs is None: + * raise TypeError('ExprCons already has lower bound') # <<<<<<<<<<<<<< + * assert self._lhs is None + * assert not self._rhs is None + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_ExprCons_already_has_lower_bound); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "src/pyscipopt/expr.pxi":511 + * expo = buildGenExprObj(other) + * if expo.getOp() != Operator.const: + * raise NotImplementedError("exponents must be numbers") # <<<<<<<<<<<<<< + * if self.getOp() == Operator.const: + * return Constant(self.number**expo.number) + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_exponents_must_be_numbers); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 511, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "src/pyscipopt/expr.pxi":525 + * # we can't divide by 0 + * if divisor.getOp() == Operator.const and divisor.number == 0.0: + * raise ZeroDivisionError("cannot divide by 0") # <<<<<<<<<<<<<< + * return self * divisor**(-1) + * + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_cannot_divide_by_0); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "src/pyscipopt/lp.pxi":20 + * PY_SCIP_CALL(SCIPlpiCreate(&(self.lpi), NULL, n, SCIP_OBJSEN_MAXIMIZE)) + * else: + * raise Warning("unrecognized objective sense") # <<<<<<<<<<<<<< + * + * def __dealloc__(self): + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_unrecognized_objective_sense); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(2, 20, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "src/pyscipopt/benders.pxi":38 + * def benderscreatesub(self, probnumber): + * '''creates the subproblems and registers it with the Benders decomposition struct ''' + * print("python error in benderscreatesub: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_benderscreatesub); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(3, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "src/pyscipopt/benders.pxi":63 + * def bendersgetvar(self, variable, probnumber): + * '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. ''' + * print("python error in bendersgetvar: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_bendersgetvar_th); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(3, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "src/pyscipopt/benders.pxi":143 + * enfotype = type + * result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) + * infeasible[0] = result_dict.get("infeasible", False) # <<<<<<<<<<<<<< + * auxviol[0] = result_dict.get("auxviol", False) + * skipsolve[0] = result_dict.get("skipsolve", False) + */ + __pyx_tuple__14 = PyTuple_Pack(2, __pyx_n_u_infeasible, Py_False); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(3, 143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "src/pyscipopt/benders.pxi":144 + * result_dict = PyBenders.benderspresubsolve(solution, enfotype, checkint) + * infeasible[0] = result_dict.get("infeasible", False) + * auxviol[0] = result_dict.get("auxviol", False) # <<<<<<<<<<<<<< + * skipsolve[0] = result_dict.get("skipsolve", False) + * result[0] = result_dict.get("result", result[0]) + */ + __pyx_tuple__15 = PyTuple_Pack(2, __pyx_n_u_auxviol, Py_False); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(3, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "src/pyscipopt/benders.pxi":145 + * infeasible[0] = result_dict.get("infeasible", False) + * auxviol[0] = result_dict.get("auxviol", False) + * skipsolve[0] = result_dict.get("skipsolve", False) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_tuple__16 = PyTuple_Pack(2, __pyx_n_u_skipsolve, Py_False); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(3, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "src/pyscipopt/benders.pxi":158 + * solution = Solution.create(scip, sol) + * result_dict = PyBenders.benderssolvesubconvex(solution, probnumber, onlyconvex) + * objective[0] = result_dict.get("objective", 1e+20) # <<<<<<<<<<<<<< + * result[0] = result_dict.get("result", result[0]) + * return SCIP_OKAY + */ + __pyx_tuple__17 = PyTuple_Pack(2, __pyx_n_u_objective, __pyx_float_1e_20); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(3, 158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "src/pyscipopt/benders.pxi":190 + * mergecandidates.append(mergecands[i]) + * result_dict = PyBenders.benderspostsolve(solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible) + * merged[0] = result_dict.get("merged", False) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_tuple__18 = PyTuple_Pack(2, __pyx_n_u_merged, Py_False); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(3, 190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + + /* "src/pyscipopt/benders.pxi":207 + * PyVar = getPyVar(var) + * result_dict = PyBenders.bendersgetvar(PyVar, probnumber) + * mappedvariable = (result_dict.get("mappedvar", None)) # <<<<<<<<<<<<<< + * if mappedvariable is None: + * mappedvar[0] = NULL + */ + __pyx_tuple__19 = PyTuple_Pack(2, __pyx_n_u_mappedvar, Py_None); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(3, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + + /* "src/pyscipopt/benderscut.pxi":24 + * + * def benderscutexec(self, solution, probnumber, enfotype): + * print("python error in benderscutexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_benderscutexec_t); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(7, 24, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + + /* "src/pyscipopt/branchrule.pxi":28 + * def branchexeclp(self, allowaddcons): + * '''executes branching rule for fractional LP solution''' + * raise NotImplementedError("branchexeclp() is a fundamental callback and should be implemented in the derived " # <<<<<<<<<<<<<< + * "class") + * + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_u_branchexeclp_is_a_fundamental_ca); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(8, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + + /* "src/pyscipopt/branchrule.pxi":33 + * def branchexecext(self, allowaddcons): + * '''executes branching rule for external branching candidates ''' + * raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") # <<<<<<<<<<<<<< + * + * def branchexecps(self, allowaddcons): + */ + __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_u_branchexecext_is_a_fundamental_c); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(8, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "src/pyscipopt/branchrule.pxi":38 + * '''executes branching rule for not completely fixed pseudo solution ''' + * # this method needs to be implemented by the user + * raise NotImplementedError("branchexecps() is a fundamental callback and should be implemented in the derived class") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_u_branchexecps_is_a_fundamental_ca); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(8, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + + /* "src/pyscipopt/conshdlr.pxi":58 + * def consenfolp(self, constraints, nusefulconss, solinfeasible): + * '''calls enforcing method of constraint handler for LP solution for all constraints added''' + * print("python error in consenfolp: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_consenfolp_this); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(9, 58, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "src/pyscipopt/conshdlr.pxi":63 + * def consenforelax(self, solution, constraints, nusefulconss, solinfeasible): + * '''calls enforcing method of constraint handler for a relaxation solution for all constraints added''' + * print("python error in consenforelax: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_consenforelax_th); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(9, 63, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "src/pyscipopt/conshdlr.pxi":68 + * def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible): + * '''calls enforcing method of constraint handler for pseudo solution for all constraints added''' + * print("python error in consenfops: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_consenfops_this); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(9, 68, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "src/pyscipopt/conshdlr.pxi":73 + * def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely): + * '''calls feasibility check method of constraint handler ''' + * print("python error in conscheck: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_conscheck_this_m); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(9, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + + /* "src/pyscipopt/conshdlr.pxi":92 + * def conslock(self, constraint, locktype, nlockspos, nlocksneg): + * '''variable rounding lock method of constraint handler''' + * print("python error in conslock: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_conslock_this_me); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(9, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + + /* "src/pyscipopt/conshdlr.pxi":451 + * PyCons = getPyCons(cons) + * result_dict = PyConshdlr.consgetnvars(PyCons) + * nvars[0] = result_dict.get("nvars", 0) # <<<<<<<<<<<<<< + * success[0] = result_dict.get("success", False) + * return SCIP_OKAY + */ + __pyx_tuple__29 = PyTuple_Pack(2, __pyx_n_u_nvars, __pyx_int_0); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(9, 451, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + + /* "src/pyscipopt/conshdlr.pxi":452 + * result_dict = PyConshdlr.consgetnvars(PyCons) + * nvars[0] = result_dict.get("nvars", 0) + * success[0] = result_dict.get("success", False) # <<<<<<<<<<<<<< + * return SCIP_OKAY + * + */ + __pyx_tuple__30 = PyTuple_Pack(2, __pyx_n_u_success, Py_False); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(9, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + + /* "src/pyscipopt/cutsel.pxi":96 + * cuts[i] = ((cut).scip_row) + * + * nselectedcuts[0] = result_dict.get('nselectedcuts', 0) # <<<<<<<<<<<<<< + * result[0] = result_dict.get('result', result[0]) + * + */ + __pyx_tuple__31 = PyTuple_Pack(2, __pyx_n_u_nselectedcuts, __pyx_int_0); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(10, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + + /* "src/pyscipopt/event.pxi":37 + * def eventexec(self, event): + * '''calls execution method of event handler ''' + * print("python error in eventexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_eventexec_this_m); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(11, 37, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__32); + __Pyx_GIVEREF(__pyx_tuple__32); + + /* "src/pyscipopt/heuristic.pxi":29 + * def heurexec(self, heurtiming, nodeinfeasible): + * '''should the heuristic the executed at the given depth, frequency, timing,...''' + * print("python error in heurexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_heurexec_this_me); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(12, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); + + /* "src/pyscipopt/presol.pxi":28 + * def presolexec(self, nrounds, presoltiming): + * '''executes presolver''' + * print("python error in presolexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_presolexec_this); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(13, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__34); + __Pyx_GIVEREF(__pyx_tuple__34); + + /* "src/pyscipopt/presol.pxi":83 + * result_dict = PyPresol.presolexec(nrounds, presoltiming) + * result[0] = result_dict.get("result", result[0]) + * nfixedvars[0] += result_dict.get("nnewfixedvars", 0) # <<<<<<<<<<<<<< + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + */ + __pyx_tuple__35 = PyTuple_Pack(2, __pyx_n_u_nnewfixedvars, __pyx_int_0); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(13, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); + + /* "src/pyscipopt/presol.pxi":84 + * result[0] = result_dict.get("result", result[0]) + * nfixedvars[0] += result_dict.get("nnewfixedvars", 0) + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) # <<<<<<<<<<<<<< + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + * nchgbds[0] += result_dict.get("nnewchgbds", 0) + */ + __pyx_tuple__36 = PyTuple_Pack(2, __pyx_n_u_nnewaggrvars, __pyx_int_0); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(13, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__36); + __Pyx_GIVEREF(__pyx_tuple__36); + + /* "src/pyscipopt/presol.pxi":85 + * nfixedvars[0] += result_dict.get("nnewfixedvars", 0) + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) # <<<<<<<<<<<<<< + * nchgbds[0] += result_dict.get("nnewchgbds", 0) + * naddholes[0] += result_dict.get("nnewaddholes", 0) + */ + __pyx_tuple__37 = PyTuple_Pack(2, __pyx_n_u_nnewchgvartypes, __pyx_int_0); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(13, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__37); + __Pyx_GIVEREF(__pyx_tuple__37); + + /* "src/pyscipopt/presol.pxi":86 + * naggrvars[0] += result_dict.get("nnewaggrvars", 0) + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + * nchgbds[0] += result_dict.get("nnewchgbds", 0) # <<<<<<<<<<<<<< + * naddholes[0] += result_dict.get("nnewaddholes", 0) + * ndelconss[0] += result_dict.get("nnewdelconss", 0) + */ + __pyx_tuple__38 = PyTuple_Pack(2, __pyx_n_u_nnewchgbds, __pyx_int_0); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(13, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__38); + __Pyx_GIVEREF(__pyx_tuple__38); + + /* "src/pyscipopt/presol.pxi":87 + * nchgvartypes[0] += result_dict.get("nnewchgvartypes", 0) + * nchgbds[0] += result_dict.get("nnewchgbds", 0) + * naddholes[0] += result_dict.get("nnewaddholes", 0) # <<<<<<<<<<<<<< + * ndelconss[0] += result_dict.get("nnewdelconss", 0) + * naddconss[0] += result_dict.get("nnewaddconss", 0) + */ + __pyx_tuple__39 = PyTuple_Pack(2, __pyx_n_u_nnewaddholes, __pyx_int_0); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(13, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__39); + __Pyx_GIVEREF(__pyx_tuple__39); + + /* "src/pyscipopt/presol.pxi":88 + * nchgbds[0] += result_dict.get("nnewchgbds", 0) + * naddholes[0] += result_dict.get("nnewaddholes", 0) + * ndelconss[0] += result_dict.get("nnewdelconss", 0) # <<<<<<<<<<<<<< + * naddconss[0] += result_dict.get("nnewaddconss", 0) + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + */ + __pyx_tuple__40 = PyTuple_Pack(2, __pyx_n_u_nnewdelconss, __pyx_int_0); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(13, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__40); + __Pyx_GIVEREF(__pyx_tuple__40); + + /* "src/pyscipopt/presol.pxi":89 + * naddholes[0] += result_dict.get("nnewaddholes", 0) + * ndelconss[0] += result_dict.get("nnewdelconss", 0) + * naddconss[0] += result_dict.get("nnewaddconss", 0) # <<<<<<<<<<<<<< + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) + */ + __pyx_tuple__41 = PyTuple_Pack(2, __pyx_n_u_nnewaddconss, __pyx_int_0); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(13, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__41); + __Pyx_GIVEREF(__pyx_tuple__41); + + /* "src/pyscipopt/presol.pxi":90 + * ndelconss[0] += result_dict.get("nnewdelconss", 0) + * naddconss[0] += result_dict.get("nnewaddconss", 0) + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) # <<<<<<<<<<<<<< + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) + * nchgsides[0] += result_dict.get("nnewchgsides", 0) + */ + __pyx_tuple__42 = PyTuple_Pack(2, __pyx_n_u_nnewupgdconss, __pyx_int_0); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(13, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__42); + __Pyx_GIVEREF(__pyx_tuple__42); + + /* "src/pyscipopt/presol.pxi":91 + * naddconss[0] += result_dict.get("nnewaddconss", 0) + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) # <<<<<<<<<<<<<< + * nchgsides[0] += result_dict.get("nnewchgsides", 0) + * return SCIP_OKAY + */ + __pyx_tuple__43 = PyTuple_Pack(2, __pyx_n_u_nnewchgcoefs, __pyx_int_0); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(13, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); + + /* "src/pyscipopt/presol.pxi":92 + * nupgdconss[0] += result_dict.get("nnewupgdconss", 0) + * nchgcoefs[0] += result_dict.get("nnewchgcoefs", 0) + * nchgsides[0] += result_dict.get("nnewchgsides", 0) # <<<<<<<<<<<<<< + * return SCIP_OKAY + */ + __pyx_tuple__44 = PyTuple_Pack(2, __pyx_n_u_nnewchgsides, __pyx_int_0); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(13, 92, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__44); + __Pyx_GIVEREF(__pyx_tuple__44); + + /* "src/pyscipopt/pricer.pxi":28 + * def pricerredcost(self): + * '''calls reduced cost pricing method of variable pricer''' + * raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") # <<<<<<<<<<<<<< + * + * def pricerfarkas(self): + */ + __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_pricerredcost_is_a_fundamental_c); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(14, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); + + /* "src/pyscipopt/pricer.pxi":32 + * def pricerfarkas(self): + * '''calls Farkas pricing method of variable pricer''' + * raise NotImplementedError("pricerfarkas() is a fundamental callback and should be implemented in the derived class") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_u_pricerfarkas_is_a_fundamental_ca); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(14, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__46); + __Pyx_GIVEREF(__pyx_tuple__46); + + /* "src/pyscipopt/propagator.pxi":40 + * def propexec(self, proptiming): + * '''calls execution method of propagator''' + * print("python error in propexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_propexec_this_me); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(15, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__47); + __Pyx_GIVEREF(__pyx_tuple__47); + + /* "src/pyscipopt/propagator.pxi":45 + * def propresprop(self, confvar, inferinfo, bdtype, relaxedbd): + * '''resolves the given conflicting bound, that was reduced by the given propagator''' + * print("python error in propresprop: this method needs to be implemented") # <<<<<<<<<<<<<< + * return {} + * + */ + __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_propresprop_this); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(15, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__48); + __Pyx_GIVEREF(__pyx_tuple__48); + + /* "src/pyscipopt/relax.pxi":29 + * def relaxexec(self): + * '''callls execution method of relaxation handler''' + * print("python error in relaxexec: this method needs to be implemented") # <<<<<<<<<<<<<< + * return{} + * + */ + __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_u_python_error_in_relaxexec_this_m); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(18, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__49); + __Pyx_GIVEREF(__pyx_tuple__49); + + /* "src/pyscipopt/nodesel.pxi":90 + * PyNodesel = nodeseldata + * result_dict = PyNodesel.nodeselect() + * selected_node = (result_dict.get("selnode", None)) # <<<<<<<<<<<<<< + * selnode[0] = selected_node.scip_node + * return SCIP_OKAY + */ + __pyx_tuple__50 = PyTuple_Pack(2, __pyx_n_u_selnode, Py_None); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(19, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__50); + __Pyx_GIVEREF(__pyx_tuple__50); + + /* "src/pyscipopt/scip.pxi":264 + * pass + * elif rc == SCIP_ERROR: + * raise Exception('SCIP: unspecified error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_NOMEMORY: + * raise MemoryError('SCIP: insufficient memory error!') + */ + __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_SCIP_unspecified_error); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__51); + __Pyx_GIVEREF(__pyx_tuple__51); + + /* "src/pyscipopt/scip.pxi":266 + * raise Exception('SCIP: unspecified error!') + * elif rc == SCIP_NOMEMORY: + * raise MemoryError('SCIP: insufficient memory error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_READERROR: + * raise IOError('SCIP: read error!') + */ + __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_SCIP_insufficient_memory_error); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__52); + __Pyx_GIVEREF(__pyx_tuple__52); + + /* "src/pyscipopt/scip.pxi":268 + * raise MemoryError('SCIP: insufficient memory error!') + * elif rc == SCIP_READERROR: + * raise IOError('SCIP: read error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_WRITEERROR: + * raise IOError('SCIP: write error!') + */ + __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_SCIP_read_error); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__53); + __Pyx_GIVEREF(__pyx_tuple__53); + + /* "src/pyscipopt/scip.pxi":270 + * raise IOError('SCIP: read error!') + * elif rc == SCIP_WRITEERROR: + * raise IOError('SCIP: write error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_NOFILE: + * raise IOError('SCIP: file not found error!') + */ + __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_u_SCIP_write_error); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__54); + __Pyx_GIVEREF(__pyx_tuple__54); + + /* "src/pyscipopt/scip.pxi":272 + * raise IOError('SCIP: write error!') + * elif rc == SCIP_NOFILE: + * raise IOError('SCIP: file not found error!') # <<<<<<<<<<<<<< + * elif rc == SCIP_FILECREATEERROR: + * raise IOError('SCIP: cannot create file!') + */ + __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_SCIP_file_not_found_error); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__55); + __Pyx_GIVEREF(__pyx_tuple__55); + + /* "src/pyscipopt/scip.pxi":274 + * raise IOError('SCIP: file not found error!') + * elif rc == SCIP_FILECREATEERROR: + * raise IOError('SCIP: cannot create file!') # <<<<<<<<<<<<<< + * elif rc == SCIP_LPERROR: + * raise Exception('SCIP: error in LP solver!') + */ + __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_u_SCIP_cannot_create_file); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__56); + __Pyx_GIVEREF(__pyx_tuple__56); + + /* "src/pyscipopt/scip.pxi":276 + * raise IOError('SCIP: cannot create file!') + * elif rc == SCIP_LPERROR: + * raise Exception('SCIP: error in LP solver!') # <<<<<<<<<<<<<< + * elif rc == SCIP_NOPROBLEM: + * raise Exception('SCIP: no problem exists!') + */ + __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_SCIP_error_in_LP_solver); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__57); + __Pyx_GIVEREF(__pyx_tuple__57); + + /* "src/pyscipopt/scip.pxi":278 + * raise Exception('SCIP: error in LP solver!') + * elif rc == SCIP_NOPROBLEM: + * raise Exception('SCIP: no problem exists!') # <<<<<<<<<<<<<< + * elif rc == SCIP_INVALIDCALL: + * raise Exception('SCIP: method cannot be called at this time' + */ + __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_u_SCIP_no_problem_exists); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__58); + __Pyx_GIVEREF(__pyx_tuple__58); + + /* "src/pyscipopt/scip.pxi":280 + * raise Exception('SCIP: no problem exists!') + * elif rc == SCIP_INVALIDCALL: + * raise Exception('SCIP: method cannot be called at this time' # <<<<<<<<<<<<<< + * + ' in solution process!') + * elif rc == SCIP_INVALIDDATA: + */ + __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_SCIP_method_cannot_be_called_at); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__59); + __Pyx_GIVEREF(__pyx_tuple__59); + + /* "src/pyscipopt/scip.pxi":283 + * + ' in solution process!') + * elif rc == SCIP_INVALIDDATA: + * raise Exception('SCIP: error in input data!') # <<<<<<<<<<<<<< + * elif rc == SCIP_INVALIDRESULT: + * raise Exception('SCIP: method returned an invalid result code!') + */ + __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_u_SCIP_error_in_input_data); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__60); + __Pyx_GIVEREF(__pyx_tuple__60); + + /* "src/pyscipopt/scip.pxi":285 + * raise Exception('SCIP: error in input data!') + * elif rc == SCIP_INVALIDRESULT: + * raise Exception('SCIP: method returned an invalid result code!') # <<<<<<<<<<<<<< + * elif rc == SCIP_PLUGINNOTFOUND: + * raise Exception('SCIP: a required plugin was not found !') + */ + __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_u_SCIP_method_returned_an_invalid); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__61); + __Pyx_GIVEREF(__pyx_tuple__61); + + /* "src/pyscipopt/scip.pxi":287 + * raise Exception('SCIP: method returned an invalid result code!') + * elif rc == SCIP_PLUGINNOTFOUND: + * raise Exception('SCIP: a required plugin was not found !') # <<<<<<<<<<<<<< + * elif rc == SCIP_PARAMETERUNKNOWN: + * raise KeyError('SCIP: the parameter with the given name was not found!') + */ + __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_u_SCIP_a_required_plugin_was_not_f); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__62); + __Pyx_GIVEREF(__pyx_tuple__62); + + /* "src/pyscipopt/scip.pxi":289 + * raise Exception('SCIP: a required plugin was not found !') + * elif rc == SCIP_PARAMETERUNKNOWN: + * raise KeyError('SCIP: the parameter with the given name was not found!') # <<<<<<<<<<<<<< + * elif rc == SCIP_PARAMETERWRONGTYPE: + * raise LookupError('SCIP: the parameter is not of the expected type!') + */ + __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_u_SCIP_the_parameter_with_the_give); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__63); + __Pyx_GIVEREF(__pyx_tuple__63); + + /* "src/pyscipopt/scip.pxi":291 + * raise KeyError('SCIP: the parameter with the given name was not found!') + * elif rc == SCIP_PARAMETERWRONGTYPE: + * raise LookupError('SCIP: the parameter is not of the expected type!') # <<<<<<<<<<<<<< + * elif rc == SCIP_PARAMETERWRONGVAL: + * raise ValueError('SCIP: the value is invalid for the given parameter!') + */ + __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_u_SCIP_the_parameter_is_not_of_the); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__64); + __Pyx_GIVEREF(__pyx_tuple__64); + + /* "src/pyscipopt/scip.pxi":293 + * raise LookupError('SCIP: the parameter is not of the expected type!') + * elif rc == SCIP_PARAMETERWRONGVAL: + * raise ValueError('SCIP: the value is invalid for the given parameter!') # <<<<<<<<<<<<<< + * elif rc == SCIP_KEYALREADYEXISTING: + * raise KeyError('SCIP: the given key is already existing in table!') + */ + __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_u_SCIP_the_value_is_invalid_for_th); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__65); + __Pyx_GIVEREF(__pyx_tuple__65); + + /* "src/pyscipopt/scip.pxi":295 + * raise ValueError('SCIP: the value is invalid for the given parameter!') + * elif rc == SCIP_KEYALREADYEXISTING: + * raise KeyError('SCIP: the given key is already existing in table!') # <<<<<<<<<<<<<< + * elif rc == SCIP_MAXDEPTHLEVEL: + * raise Exception('SCIP: maximal branching depth level exceeded!') + */ + __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_u_SCIP_the_given_key_is_already_ex); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__66); + __Pyx_GIVEREF(__pyx_tuple__66); + + /* "src/pyscipopt/scip.pxi":297 + * raise KeyError('SCIP: the given key is already existing in table!') + * elif rc == SCIP_MAXDEPTHLEVEL: + * raise Exception('SCIP: maximal branching depth level exceeded!') # <<<<<<<<<<<<<< + * else: + * raise Exception('SCIP: unknown return code!') + */ + __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_u_SCIP_maximal_branching_depth_lev); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__67); + __Pyx_GIVEREF(__pyx_tuple__67); + + /* "src/pyscipopt/scip.pxi":299 + * raise Exception('SCIP: maximal branching depth level exceeded!') + * else: + * raise Exception('SCIP: unknown return code!') # <<<<<<<<<<<<<< + * + * cdef class Event: + */ + __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_u_SCIP_unknown_return_code); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__68); + __Pyx_GIVEREF(__pyx_tuple__68); + + /* "src/pyscipopt/scip.pxi":307 + * cdef create(SCIP_EVENT* scip_event): + * if scip_event == NULL: + * raise Warning("cannot create Event with SCIP_EVENT* == NULL") # <<<<<<<<<<<<<< + * event = Event() + * event.event = scip_event + */ + __pyx_tuple__69 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_Event_with_SCIP_EV); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(0, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__69); + __Pyx_GIVEREF(__pyx_tuple__69); + + /* "src/pyscipopt/scip.pxi":371 + * cdef create(SCIP_COL* scipcol): + * if scipcol == NULL: + * raise Warning("cannot create Column with SCIP_COL* == NULL") # <<<<<<<<<<<<<< + * col = Column() + * col.scip_col = scipcol + */ + __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_Column_with_SCIP_C); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 371, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__70); + __Pyx_GIVEREF(__pyx_tuple__70); + + /* "src/pyscipopt/scip.pxi":392 + * return "zero" + * else: + * raise Exception('SCIP returned unknown base status!') # <<<<<<<<<<<<<< + * + * def isIntegral(self): + */ + __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_SCIP_returned_unknown_base_statu); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 392, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__71); + __Pyx_GIVEREF(__pyx_tuple__71); + + /* "src/pyscipopt/scip.pxi":432 + * cdef create(SCIP_ROW* sciprow): + * if sciprow == NULL: + * raise Warning("cannot create Row with SCIP_ROW* == NULL") # <<<<<<<<<<<<<< + * row = Row() + * row.scip_row = sciprow + */ + __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_Row_with_SCIP_ROW); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__72); + __Pyx_GIVEREF(__pyx_tuple__72); + + /* "src/pyscipopt/scip.pxi":469 + * elif stat == SCIP_BASESTAT_ZERO: + * # this shouldn't happen! + * raise Exception('SCIP returned base status zero for a row!') # <<<<<<<<<<<<<< + * else: + * raise Exception('SCIP returned unknown base status!') + */ + __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_u_SCIP_returned_base_status_zero_f); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(0, 469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__73); + __Pyx_GIVEREF(__pyx_tuple__73); + + /* "src/pyscipopt/scip.pxi":537 + * cdef create(SCIP_NLROW* scipnlrow): + * if scipnlrow == NULL: + * raise Warning("cannot create NLRow with SCIP_NLROW* == NULL") # <<<<<<<<<<<<<< + * nlrow = NLRow() + * nlrow.scip_nlrow = scipnlrow + */ + __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_NLRow_with_SCIP_NL); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__74); + __Pyx_GIVEREF(__pyx_tuple__74); + + /* "src/pyscipopt/scip.pxi":583 + * def __init__(self, raise_error = False): + * if not raise_error: + * raise ValueError("To create a solution you should use the createSol method of the Model class.") # <<<<<<<<<<<<<< + * + * @staticmethod + */ + __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_u_To_create_a_solution_you_should); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__75); + __Pyx_GIVEREF(__pyx_tuple__75); + + /* "src/pyscipopt/scip.pxi":588 + * cdef create(SCIP* scip, SCIP_SOL* scip_sol): + * if scip == NULL: + * raise Warning("cannot create Solution with SCIP* == NULL") # <<<<<<<<<<<<<< + * sol = Solution(True) + * sol.sol = scip_sol + */ + __pyx_tuple__76 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_Solution_with_SCIP); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__76); + __Pyx_GIVEREF(__pyx_tuple__76); + + /* "src/pyscipopt/scip.pxi":589 + * if scip == NULL: + * raise Warning("cannot create Solution with SCIP* == NULL") + * sol = Solution(True) # <<<<<<<<<<<<<< + * sol.sol = scip_sol + * sol.scip = scip + */ + __pyx_tuple__77 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(0, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__77); + __Pyx_GIVEREF(__pyx_tuple__77); + + /* "src/pyscipopt/scip.pxi":639 + * cdef create(SCIP_BOUNDCHG* scip_boundchg): + * if scip_boundchg == NULL: + * raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL") # <<<<<<<<<<<<<< + * boundchg = BoundChange() + * boundchg.scip_boundchg = scip_boundchg + */ + __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_BoundChange_with_S); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__78); + __Pyx_GIVEREF(__pyx_tuple__78); + + /* "src/pyscipopt/scip.pxi":675 + * cdef create(SCIP_DOMCHG* scip_domchg): + * if scip_domchg == NULL: + * raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL") # <<<<<<<<<<<<<< + * domchg = DomainChanges() + * domchg.scip_domchg = scip_domchg + */ + __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_DomainChanges_with); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__80); + __Pyx_GIVEREF(__pyx_tuple__80); + + /* "src/pyscipopt/scip.pxi":810 + * cdef create(SCIP_VAR* scipvar): + * if scipvar == NULL: + * raise Warning("cannot create Variable with SCIP_VAR* == NULL") # <<<<<<<<<<<<<< + * var = Variable() + * var.scip_var = scipvar + */ + __pyx_tuple__81 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_Variable_with_SCIP); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(0, 810, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__81); + __Pyx_GIVEREF(__pyx_tuple__81); + + /* "src/pyscipopt/scip.pxi":897 + * cdef create(SCIP_CONS* scipcons): + * if scipcons == NULL: + * raise Warning("cannot create Constraint with SCIP_CONS* == NULL") # <<<<<<<<<<<<<< + * cons = Constraint() + * cons.scip_cons = scipcons + */ + __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_Constraint_with_SC); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__82); + __Pyx_GIVEREF(__pyx_tuple__82); + + /* "src/pyscipopt/scip.pxi":1053 + * """ + * if scip == NULL: + * raise Warning("cannot create Model with SCIP* == NULL") # <<<<<<<<<<<<<< + * model = Model(createscip=False) + * model._scip = scip + */ + __pyx_tuple__83 = PyTuple_Pack(1, __pyx_kp_u_cannot_create_Model_with_SCIP_NU); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 1053, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__83); + __Pyx_GIVEREF(__pyx_tuple__83); + + /* "src/pyscipopt/scip.pxi":1083 + * """ + * if not PyCapsule_IsValid(capsule, "scip"): + * raise ValueError("The given capsule does not contain a valid scip pointer") # <<<<<<<<<<<<<< + * model = Model.create(PyCapsule_GetPointer(capsule, "scip")) + * model._freescip = take_ownership + */ + __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_u_The_given_capsule_does_not_conta); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 1083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__84); + __Pyx_GIVEREF(__pyx_tuple__84); + + /* "src/pyscipopt/scip.pxi":1347 + * + * if expr.degree() > 1: + * raise ValueError("SCIP does not support nonlinear objective functions. Consider using set_nonlinear_objective in the pyscipopt.recipe.nonlinear") # <<<<<<<<<<<<<< + * + * if clear: + */ + __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_u_SCIP_does_not_support_nonlinear); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 1347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__85); + __Pyx_GIVEREF(__pyx_tuple__85); + + /* "src/pyscipopt/scip.pxi":1464 + * + * """ + * self.setIntParam("propagating/maxroundsroot", 0) # <<<<<<<<<<<<<< + * if not onlyroot: + * self.setIntParam("propagating/maxrounds", 0) + */ + __pyx_tuple__86 = PyTuple_Pack(2, __pyx_kp_u_propagating_maxroundsroot, __pyx_int_0); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 1464, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__86); + __Pyx_GIVEREF(__pyx_tuple__86); + + /* "src/pyscipopt/scip.pxi":1466 + * self.setIntParam("propagating/maxroundsroot", 0) + * if not onlyroot: + * self.setIntParam("propagating/maxrounds", 0) # <<<<<<<<<<<<<< + * + * def writeProblem(self, filename='model.cip', trans=False, genericnames=False, verbose=True): + */ + __pyx_tuple__87 = PyTuple_Pack(2, __pyx_kp_u_propagating_maxrounds, __pyx_int_0); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 1466, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__87); + __Pyx_GIVEREF(__pyx_tuple__87); + + /* "src/pyscipopt/scip.pxi":1486 + * ext = str_conversion('.cip') + * fn = fn + ext + * ext = ext[1:] # <<<<<<<<<<<<<< + * + * if trans: + */ + __pyx_slice__88 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__88)) __PYX_ERR(0, 1486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__88); + __Pyx_GIVEREF(__pyx_slice__88); + + /* "src/pyscipopt/scip.pxi":1540 + * PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_IMPLINT)) + * else: + * raise Warning("unrecognized variable type") # <<<<<<<<<<<<<< + * + * if pricedVar: + */ + __pyx_tuple__90 = PyTuple_Pack(1, __pyx_kp_u_unrecognized_variable_type); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(0, 1540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__90); + __Pyx_GIVEREF(__pyx_tuple__90); + + /* "src/pyscipopt/scip.pxi":1827 + * """Relaxes the integrality restrictions of the model""" + * if self.getStage() != SCIP_STAGE_PROBLEM: + * raise Warning("method can only be called in stage PROBLEM") # <<<<<<<<<<<<<< + * + * for var in self.getVars(): + */ + __pyx_tuple__91 = PyTuple_Pack(1, __pyx_kp_u_method_can_only_be_called_in_sta); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(0, 1827, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__91); + __Pyx_GIVEREF(__pyx_tuple__91); + + /* "src/pyscipopt/scip.pxi":2469 + * :see addCons() + * """ + * def ensure_iterable(elem, length): # <<<<<<<<<<<<<< + * if isinstance(elem, Iterable): + * return elem + */ + __pyx_tuple__92 = PyTuple_Pack(2, __pyx_n_s_elem, __pyx_n_s_length); if (unlikely(!__pyx_tuple__92)) __PYX_ERR(0, 2469, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__92); + __Pyx_GIVEREF(__pyx_tuple__92); + __pyx_codeobj__93 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__92, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_ensure_iterable, 2469, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__93)) __PYX_ERR(0, 2469, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2522 + * :return The added @ref scip#Constraint "Constraint" object. + * """ + * def ensure_iterable(elem, length): # <<<<<<<<<<<<<< + * if isinstance(elem, Iterable): + * return elem + */ + __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__92, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_ensure_iterable, 2522, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) __PYX_ERR(0, 2522, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2945 + * cdef SCIP_VAR* _binVar + * if cons._lhs is not None and cons._rhs is not None: + * raise ValueError("expected inequality that has either only a left or right hand side") # <<<<<<<<<<<<<< + * + * if cons.expr.degree() > 1: + */ + __pyx_tuple__96 = PyTuple_Pack(1, __pyx_kp_u_expected_inequality_that_has_eit); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(0, 2945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__96); + __Pyx_GIVEREF(__pyx_tuple__96); + + /* "src/pyscipopt/scip.pxi":3187 + * + * if not self.getStage() >= SCIP_STAGE_SOLVING: + * raise Warning("method cannot be called before problem is solved") # <<<<<<<<<<<<<< + * + * if isinstance(sol, Solution): + */ + __pyx_tuple__97 = PyTuple_Pack(1, __pyx_kp_u_method_cannot_be_called_before_p); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(0, 3187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__97); + __Pyx_GIVEREF(__pyx_tuple__97); + + /* "src/pyscipopt/scip.pxi":3479 + * + * """ + * raise Warning("model.getDualMultiplier(cons) is deprecated: please use model.getDualsolLinear(cons)") # <<<<<<<<<<<<<< + * return self.getDualsolLinear(cons) + * + */ + __pyx_tuple__98 = PyTuple_Pack(1, __pyx_kp_u_model_getDualMultiplier_cons_is); if (unlikely(!__pyx_tuple__98)) __PYX_ERR(0, 3479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__98); + __Pyx_GIVEREF(__pyx_tuple__98); + + /* "src/pyscipopt/scip.pxi":3579 + * + * # activating the Benders' decomposition constraint handlers + * self.setBoolParam("constraints/benderslp/active", True) # <<<<<<<<<<<<<< + * self.setBoolParam("constraints/benders/active", True) + * #self.setIntParam("limits/maxorigsol", 0) + */ + __pyx_tuple__99 = PyTuple_Pack(2, __pyx_kp_u_constraints_benderslp_active, Py_True); if (unlikely(!__pyx_tuple__99)) __PYX_ERR(0, 3579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__99); + __Pyx_GIVEREF(__pyx_tuple__99); + + /* "src/pyscipopt/scip.pxi":3580 + * # activating the Benders' decomposition constraint handlers + * self.setBoolParam("constraints/benderslp/active", True) + * self.setBoolParam("constraints/benders/active", True) # <<<<<<<<<<<<<< + * #self.setIntParam("limits/maxorigsol", 0) + * + */ + __pyx_tuple__100 = PyTuple_Pack(2, __pyx_kp_u_constraints_benders_active, Py_True); if (unlikely(!__pyx_tuple__100)) __PYX_ERR(0, 3580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__100); + __Pyx_GIVEREF(__pyx_tuple__100); + + /* "src/pyscipopt/scip.pxi":4612 + * # use this doubled opening pattern to ensure that IOErrors are + * # triggered early and in Python not in C,Cython or SCIP. + * with open(filename, "w") as f: # <<<<<<<<<<<<<< + * cfile = fdopen(f.fileno(), "w") + * PY_SCIP_CALL(SCIPprintBestSol(self._scip, cfile, write_zeros)) + */ + __pyx_tuple__107 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__107)) __PYX_ERR(0, 4612, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__107); + __Pyx_GIVEREF(__pyx_tuple__107); + + /* "src/pyscipopt/scip.pxi":5021 + * _eventhdlr = SCIPfindEventhdlr(self._scip, n) + * else: + * raise Warning("event handler not found") # <<<<<<<<<<<<<< + * + * Py_INCREF(self) + */ + __pyx_tuple__108 = PyTuple_Pack(1, __pyx_kp_u_event_handler_not_found); if (unlikely(!__pyx_tuple__108)) __PYX_ERR(0, 5021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__108); + __Pyx_GIVEREF(__pyx_tuple__108); + + /* "src/pyscipopt/scip.pxi":5216 + * + * if param == NULL: + * raise KeyError("Not a valid parameter name") # <<<<<<<<<<<<<< + * + * paramtype = SCIPparamGetType(param) + */ + __pyx_tuple__109 = PyTuple_Pack(1, __pyx_kp_u_Not_a_valid_parameter_name); if (unlikely(!__pyx_tuple__109)) __PYX_ERR(0, 5216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__109); + __Pyx_GIVEREF(__pyx_tuple__109); + + /* "src/pyscipopt/scip.pxi":5377 + * nsols = SCIPgetNCountedSols(self._scip, &valid) + * if not valid: + * print('total number of solutions found is not valid!') # <<<<<<<<<<<<<< + * return nsols + * + */ + __pyx_tuple__110 = PyTuple_Pack(1, __pyx_kp_u_total_number_of_solutions_found); if (unlikely(!__pyx_tuple__110)) __PYX_ERR(0, 5377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__110); + __Pyx_GIVEREF(__pyx_tuple__110); + + /* "src/pyscipopt/scip.pxi":5408 + * + * if coeffs.degree() > 1: + * raise ValueError("Nonlinear objective functions are not supported!") # <<<<<<<<<<<<<< + * if coeffs[CONST] != 0.0: + * raise ValueError("Constant offsets in objective are not supported!") + */ + __pyx_tuple__111 = PyTuple_Pack(1, __pyx_kp_u_Nonlinear_objective_functions_ar); if (unlikely(!__pyx_tuple__111)) __PYX_ERR(0, 5408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__111); + __Pyx_GIVEREF(__pyx_tuple__111); + + /* "src/pyscipopt/scip.pxi":5410 + * raise ValueError("Nonlinear objective functions are not supported!") + * if coeffs[CONST] != 0.0: + * raise ValueError("Constant offsets in objective are not supported!") # <<<<<<<<<<<<<< + * + * cdef SCIP_VAR** _vars + */ + __pyx_tuple__112 = PyTuple_Pack(1, __pyx_kp_u_Constant_offsets_in_objective_ar); if (unlikely(!__pyx_tuple__112)) __PYX_ERR(0, 5410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__112); + __Pyx_GIVEREF(__pyx_tuple__112); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x51d2361, 0xce620d6, 0x6f493bf): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x51d2361, 0xce620d6, 0x6f493bf) = (terms))" % __pyx_checksum + */ + __pyx_tuple__113 = PyTuple_Pack(3, __pyx_int_85795681, __pyx_int_216408278, __pyx_int_116691903); if (unlikely(!__pyx_tuple__113)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__113); + __Pyx_GIVEREF(__pyx_tuple__113); + __pyx_tuple__115 = PyTuple_Pack(3, __pyx_int_143015212, __pyx_int_25280761, __pyx_int_150239579); if (unlikely(!__pyx_tuple__115)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__115); + __Pyx_GIVEREF(__pyx_tuple__115); + __pyx_tuple__116 = PyTuple_Pack(3, __pyx_int_214626690, __pyx_int_208012509, __pyx_int_169888372); if (unlikely(!__pyx_tuple__116)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__116); + __Pyx_GIVEREF(__pyx_tuple__116); + __pyx_tuple__117 = PyTuple_Pack(3, __pyx_int_63254455, __pyx_int_152146234, __pyx_int_114651189); if (unlikely(!__pyx_tuple__117)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__117); + __Pyx_GIVEREF(__pyx_tuple__117); + __pyx_tuple__118 = PyTuple_Pack(3, __pyx_int_240430858, __pyx_int_201230365, __pyx_int_13758880); if (unlikely(!__pyx_tuple__118)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__118); + __Pyx_GIVEREF(__pyx_tuple__118); + __pyx_tuple__119 = PyTuple_Pack(3, __pyx_int_76998962, __pyx_int_135158539, __pyx_int_253686829); if (unlikely(!__pyx_tuple__119)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__119); + __Pyx_GIVEREF(__pyx_tuple__119); + __pyx_tuple__120 = PyTuple_Pack(3, __pyx_int_80720285, __pyx_int_176834982, __pyx_int_173957064); if (unlikely(!__pyx_tuple__120)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__120); + __Pyx_GIVEREF(__pyx_tuple__120); + __pyx_tuple__121 = PyTuple_Pack(3, __pyx_int_132603380, __pyx_int_204489503, __pyx_int_147635180); if (unlikely(!__pyx_tuple__121)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__121); + __Pyx_GIVEREF(__pyx_tuple__121); + __pyx_tuple__122 = PyTuple_Pack(3, __pyx_int_95355963, __pyx_int_208195651, __pyx_int_267356384); if (unlikely(!__pyx_tuple__122)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__122); + __Pyx_GIVEREF(__pyx_tuple__122); + __pyx_tuple__123 = PyTuple_Pack(3, __pyx_int_154610759, __pyx_int_30435853, __pyx_int_34551270); if (unlikely(!__pyx_tuple__123)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__123); + __Pyx_GIVEREF(__pyx_tuple__123); + __pyx_tuple__124 = PyTuple_Pack(3, __pyx_int_76513566, __pyx_int_37557029, __pyx_int_248330301); if (unlikely(!__pyx_tuple__124)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__124); + __Pyx_GIVEREF(__pyx_tuple__124); + __pyx_tuple__125 = PyTuple_Pack(3, __pyx_int_238750788, __pyx_int_228825662, __pyx_int_222419149); if (unlikely(!__pyx_tuple__125)) __PYX_ERR(6, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__125); + __Pyx_GIVEREF(__pyx_tuple__125); + + /* "src/pyscipopt/expr.pxi":47 + * + * + * def _is_number(e): # <<<<<<<<<<<<<< + * try: + * f = float(e) + */ + __pyx_tuple__127 = PyTuple_Pack(2, __pyx_n_s_e, __pyx_n_s_f); if (unlikely(!__pyx_tuple__127)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__127); + __Pyx_GIVEREF(__pyx_tuple__127); + __pyx_codeobj__128 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__127, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_is_number, 47, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__128)) __PYX_ERR(1, 47, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":57 + * + * + * def _expr_richcmp(self, other, op): # <<<<<<<<<<<<<< + * if op == 1: # <= + * if isinstance(other, Expr) or isinstance(other, GenExpr): + */ + __pyx_tuple__129 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_other, __pyx_n_s_op); if (unlikely(!__pyx_tuple__129)) __PYX_ERR(1, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__129); + __Pyx_GIVEREF(__pyx_tuple__129); + __pyx_codeobj__130 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__129, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_expr_richcmp, 57, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__130)) __PYX_ERR(1, 57, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":86 + * '''This is a monomial term''' + * + * __slots__ = ('vartuple', 'ptrtuple', 'hashval') # <<<<<<<<<<<<<< + * + * def __init__(self, *vartuple): + */ + __pyx_tuple__131 = PyTuple_Pack(3, __pyx_n_u_vartuple, __pyx_n_u_ptrtuple, __pyx_n_u_hashval); if (unlikely(!__pyx_tuple__131)) __PYX_ERR(1, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__131); + __Pyx_GIVEREF(__pyx_tuple__131); + + /* "src/pyscipopt/expr.pxi":88 + * __slots__ = ('vartuple', 'ptrtuple', 'hashval') + * + * def __init__(self, *vartuple): # <<<<<<<<<<<<<< + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + */ + __pyx_tuple__132 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_vartuple, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__132)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__132); + __Pyx_GIVEREF(__pyx_tuple__132); + __pyx_codeobj__133 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARARGS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__132, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_init, 88, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__133)) __PYX_ERR(1, 88, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":93 + * self.hashval = sum(self.ptrtuple) + * + * def __getitem__(self, idx): # <<<<<<<<<<<<<< + * return self.vartuple[idx] + * + */ + __pyx_tuple__134 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_idx); if (unlikely(!__pyx_tuple__134)) __PYX_ERR(1, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__134); + __Pyx_GIVEREF(__pyx_tuple__134); + __pyx_codeobj__135 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__134, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_getitem, 93, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__135)) __PYX_ERR(1, 93, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":96 + * return self.vartuple[idx] + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return self.hashval + * + */ + __pyx_tuple__136 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__136)) __PYX_ERR(1, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__136); + __Pyx_GIVEREF(__pyx_tuple__136); + __pyx_codeobj__137 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_hash, 96, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__137)) __PYX_ERR(1, 96, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":99 + * return self.hashval + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return self.ptrtuple == other.ptrtuple + * + */ + __pyx_tuple__138 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_other); if (unlikely(!__pyx_tuple__138)) __PYX_ERR(1, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__138); + __Pyx_GIVEREF(__pyx_tuple__138); + __pyx_codeobj__139 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__138, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_eq, 99, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__139)) __PYX_ERR(1, 99, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":102 + * return self.ptrtuple == other.ptrtuple + * + * def __len__(self): # <<<<<<<<<<<<<< + * return len(self.vartuple) + * + */ + __pyx_codeobj__140 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_len, 102, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__140)) __PYX_ERR(1, 102, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":105 + * return len(self.vartuple) + * + * def __add__(self, other): # <<<<<<<<<<<<<< + * both = self.vartuple + other.vartuple + * return Term(*both) + */ + __pyx_tuple__141 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_other, __pyx_n_s_both); if (unlikely(!__pyx_tuple__141)) __PYX_ERR(1, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__141); + __Pyx_GIVEREF(__pyx_tuple__141); + __pyx_codeobj__142 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__141, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_add, 105, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__142)) __PYX_ERR(1, 105, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":109 + * return Term(*both) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return 'Term(%s)' % ', '.join([str(v) for v in self.vartuple]) + * + */ + __pyx_tuple__143 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_v); if (unlikely(!__pyx_tuple__143)) __PYX_ERR(1, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__143); + __Pyx_GIVEREF(__pyx_tuple__143); + __pyx_codeobj__144 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__143, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_repr, 109, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__144)) __PYX_ERR(1, 109, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":116 + * + * # helper function + * def buildGenExprObj(expr): # <<<<<<<<<<<<<< + * """helper function to generate an object of type GenExpr""" + * if _is_number(expr): + */ + __pyx_tuple__145 = PyTuple_Pack(7, __pyx_n_s_expr, __pyx_n_s_sumexpr, __pyx_n_s_vars, __pyx_n_s_coef, __pyx_n_s_varexpr, __pyx_n_s_prodexpr, __pyx_n_s_v); if (unlikely(!__pyx_tuple__145)) __PYX_ERR(1, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__145); + __Pyx_GIVEREF(__pyx_tuple__145); + __pyx_codeobj__146 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__145, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_buildGenExprObj, 116, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__146)) __PYX_ERR(1, 116, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":272 + * return _expr_richcmp(self, other, op) + * + * def normalize(self): # <<<<<<<<<<<<<< + * '''remove terms with coefficient of 0''' + * self.terms = {t:c for (t,c) in self.terms.items() if c != 0.0} + */ + __pyx_tuple__147 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_t, __pyx_n_s_c); if (unlikely(!__pyx_tuple__147)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__147); + __Pyx_GIVEREF(__pyx_tuple__147); + __pyx_codeobj__148 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__147, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_normalize, 272, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__148)) __PYX_ERR(1, 272, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":279 + * return 'Expr(%s)' % repr(self.terms) + * + * def degree(self): # <<<<<<<<<<<<<< + * '''computes highest degree of terms''' + * if len(self.terms) == 0: + */ + __pyx_tuple__149 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__149)) __PYX_ERR(1, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__149); + __Pyx_GIVEREF(__pyx_tuple__149); + __pyx_codeobj__150 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__149, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_degree, 279, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__150)) __PYX_ERR(1, 279, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_tuple__151 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_state, __pyx_n_s_dict_2, __pyx_n_s_use_setstate); if (unlikely(!__pyx_tuple__151)) __PYX_ERR(6, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__151); + __Pyx_GIVEREF(__pyx_tuple__151); + __pyx_codeobj__152 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__152)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Expr__set_state(self, __pyx_state) + */ + __pyx_tuple__153 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__153)) __PYX_ERR(6, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__153); + __Pyx_GIVEREF(__pyx_tuple__153); + __pyx_codeobj__154 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__154)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":300 + * self.normalize() + * + * def normalize(self): # <<<<<<<<<<<<<< + * '''move constant terms in expression to bounds''' + * if isinstance(self.expr, Expr): + */ + __pyx_tuple__155 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_c); if (unlikely(!__pyx_tuple__155)) __PYX_ERR(1, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__155); + __Pyx_GIVEREF(__pyx_tuple__155); + __pyx_codeobj__156 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__155, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_normalize, 300, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__156)) __PYX_ERR(1, 300, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__157 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__157)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ExprCons__set_state(self, __pyx_state) + */ + __pyx_codeobj__158 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__158)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":357 + * raise TypeError(msg) + * + * def quicksum(termlist): # <<<<<<<<<<<<<< + * '''add linear expressions and constants much faster than Python's sum + * by avoiding intermediate data structures and adding terms inplace + */ + __pyx_tuple__159 = PyTuple_Pack(3, __pyx_n_s_termlist, __pyx_n_s_result, __pyx_n_s_term); if (unlikely(!__pyx_tuple__159)) __PYX_ERR(1, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__159); + __Pyx_GIVEREF(__pyx_tuple__159); + __pyx_codeobj__160 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__159, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_quicksum, 357, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__160)) __PYX_ERR(1, 357, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":366 + * return result + * + * def quickprod(termlist): # <<<<<<<<<<<<<< + * '''multiply linear expressions and constants by avoiding intermediate + * data structures and multiplying terms inplace + */ + __pyx_codeobj__161 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__159, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_quickprod, 366, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__161)) __PYX_ERR(1, 366, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":552 + * return _expr_richcmp(self, other, op) + * + * def degree(self): # <<<<<<<<<<<<<< + * '''Note: none of these expressions should be polynomial''' + * return float('inf') + */ + __pyx_codeobj__166 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_degree, 552, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__166)) __PYX_ERR(1, 552, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":556 + * return float('inf') + * + * def getOp(self): # <<<<<<<<<<<<<< + * '''returns operator of GenExpr''' + * return self._op + */ + __pyx_codeobj__167 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_getOp, 556, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__167)) __PYX_ERR(1, 556, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__168 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__168)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_GenExpr__set_state(self, __pyx_state) + */ + __pyx_codeobj__169 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__169)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__170 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__170)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_SumExpr__set_state(self, __pyx_state) + */ + __pyx_codeobj__171 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__171)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__172 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__172)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ProdExpr__set_state(self, __pyx_state) + */ + __pyx_codeobj__173 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__173)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__174 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__174)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_VarExpr, (type(self), 0x496e932, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_VarExpr__set_state(self, __pyx_state) + */ + __pyx_codeobj__175 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__175)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__176 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__176)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PowExpr__set_state(self, __pyx_state) + */ + __pyx_codeobj__177 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__177)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__178 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__178)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_UnaryExpr__set_state(self, __pyx_state) + */ + __pyx_codeobj__179 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__179)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__180 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__180)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Constant, (type(self), 0x7e75df4, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Constant__set_state(self, __pyx_state) + */ + __pyx_codeobj__181 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__181)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":623 + * return str(self.number) + * + * def exp(expr): # <<<<<<<<<<<<<< + * """returns expression with exp-function""" + * return UnaryExpr(Operator.exp, buildGenExprObj(expr)) + */ + __pyx_tuple__182 = PyTuple_Pack(1, __pyx_n_s_expr); if (unlikely(!__pyx_tuple__182)) __PYX_ERR(1, 623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__182); + __Pyx_GIVEREF(__pyx_tuple__182); + __pyx_codeobj__183 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__182, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_exp, 623, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__183)) __PYX_ERR(1, 623, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":626 + * """returns expression with exp-function""" + * return UnaryExpr(Operator.exp, buildGenExprObj(expr)) + * def log(expr): # <<<<<<<<<<<<<< + * """returns expression with log-function""" + * return UnaryExpr(Operator.log, buildGenExprObj(expr)) + */ + __pyx_codeobj__184 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__182, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_log, 626, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__184)) __PYX_ERR(1, 626, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":629 + * """returns expression with log-function""" + * return UnaryExpr(Operator.log, buildGenExprObj(expr)) + * def sqrt(expr): # <<<<<<<<<<<<<< + * """returns expression with sqrt-function""" + * return UnaryExpr(Operator.sqrt, buildGenExprObj(expr)) + */ + __pyx_codeobj__185 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__182, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_sqrt, 629, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__185)) __PYX_ERR(1, 629, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":632 + * """returns expression with sqrt-function""" + * return UnaryExpr(Operator.sqrt, buildGenExprObj(expr)) + * def sin(expr): # <<<<<<<<<<<<<< + * """returns expression with sin-function""" + * return UnaryExpr(Operator.sin, buildGenExprObj(expr)) + */ + __pyx_codeobj__186 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__182, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_sin, 632, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__186)) __PYX_ERR(1, 632, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":635 + * """returns expression with sin-function""" + * return UnaryExpr(Operator.sin, buildGenExprObj(expr)) + * def cos(expr): # <<<<<<<<<<<<<< + * """returns expression with cos-function""" + * return UnaryExpr(Operator.cos, buildGenExprObj(expr)) + */ + __pyx_codeobj__187 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__182, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_cos, 635, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__187)) __PYX_ERR(1, 635, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":639 + * return UnaryExpr(Operator.cos, buildGenExprObj(expr)) + * + * def expr_to_nodes(expr): # <<<<<<<<<<<<<< + * '''transforms tree to an array of nodes. each node is an operator and the position of the + * children of that operator (i.e. the other nodes) in the array''' + */ + __pyx_tuple__188 = PyTuple_Pack(2, __pyx_n_s_expr, __pyx_n_s_nodes); if (unlikely(!__pyx_tuple__188)) __PYX_ERR(1, 639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__188); + __Pyx_GIVEREF(__pyx_tuple__188); + __pyx_codeobj__189 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__188, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_expr_to_nodes, 639, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__189)) __PYX_ERR(1, 639, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":647 + * return nodes + * + * def value_to_array(val, nodes): # <<<<<<<<<<<<<< + * """adds a given value to an array""" + * nodes.append(tuple(['const', [val]])) + */ + __pyx_tuple__190 = PyTuple_Pack(2, __pyx_n_s_val, __pyx_n_s_nodes); if (unlikely(!__pyx_tuple__190)) __PYX_ERR(1, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__190); + __Pyx_GIVEREF(__pyx_tuple__190); + __pyx_codeobj__191 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__190, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_value_to_array, 647, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__191)) __PYX_ERR(1, 647, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":657 + * # also, for sums, we are not considering coefficients, because basically all coefficients are 1 + * # haven't even consider substractions, but I guess we would interpret them as a - b = a + (-1) * b + * def expr_to_array(expr, nodes): # <<<<<<<<<<<<<< + * """adds expression to array""" + * op = expr._op + */ + __pyx_tuple__192 = PyTuple_Pack(7, __pyx_n_s_expr, __pyx_n_s_nodes, __pyx_n_s_op, __pyx_n_s_indices, __pyx_n_s_nchildren, __pyx_n_s_child, __pyx_n_s_pos); if (unlikely(!__pyx_tuple__192)) __PYX_ERR(1, 657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__192); + __Pyx_GIVEREF(__pyx_tuple__192); + __pyx_codeobj__193 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__192, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_expr_pxi, __pyx_n_s_expr_to_array, 657, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__193)) __PYX_ERR(1, 657, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":28 + * return self.name + * + * def writeLP(self, filename): # <<<<<<<<<<<<<< + * """Writes LP to a file. + * + */ + __pyx_tuple__194 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_filename); if (unlikely(!__pyx_tuple__194)) __PYX_ERR(2, 28, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__194); + __Pyx_GIVEREF(__pyx_tuple__194); + __pyx_codeobj__195 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__194, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_writeLP, 28, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__195)) __PYX_ERR(2, 28, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":36 + * PY_SCIP_CALL(SCIPlpiWriteLP(self.lpi, filename)) + * + * def readLP(self, filename): # <<<<<<<<<<<<<< + * """Reads LP from a file. + * + */ + __pyx_codeobj__196 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__194, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_readLP, 36, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__196)) __PYX_ERR(2, 36, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":44 + * PY_SCIP_CALL(SCIPlpiReadLP(self.lpi, filename)) + * + * def infinity(self): # <<<<<<<<<<<<<< + * """Returns infinity value of the LP. + * """ + */ + __pyx_codeobj__197 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_infinity, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__197)) __PYX_ERR(2, 44, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":49 + * return SCIPlpiInfinity(self.lpi) + * + * def isInfinity(self, val): # <<<<<<<<<<<<<< + * """Checks if a given value is equal to the infinity value of the LP. + * + */ + __pyx_tuple__198 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_val); if (unlikely(!__pyx_tuple__198)) __PYX_ERR(2, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__198); + __Pyx_GIVEREF(__pyx_tuple__198); + __pyx_codeobj__199 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__198, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_isInfinity, 49, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__199)) __PYX_ERR(2, 49, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":57 + * return SCIPlpiIsInfinity(self.lpi, val) + * + * def addCol(self, entries, obj = 0.0, lb = 0.0, ub = None): # <<<<<<<<<<<<<< + * """Adds a single column to the LP. + * + */ + __pyx_tuple__200 = PyTuple_Pack(14, __pyx_n_s_self, __pyx_n_s_entries, __pyx_n_s_obj, __pyx_n_s_lb, __pyx_n_s_ub, __pyx_n_s_nnonz, __pyx_n_s_c_coefs, __pyx_n_s_c_inds, __pyx_n_s_c_obj, __pyx_n_s_c_lb, __pyx_n_s_c_ub, __pyx_n_s_c_beg, __pyx_n_s_i, __pyx_n_s_entry); if (unlikely(!__pyx_tuple__200)) __PYX_ERR(2, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__200); + __Pyx_GIVEREF(__pyx_tuple__200); + __pyx_codeobj__201 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__200, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_addCol, 57, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__201)) __PYX_ERR(2, 57, __pyx_L1_error) + __pyx_tuple__202 = PyTuple_Pack(3, __pyx_float_0_0, __pyx_float_0_0, Py_None); if (unlikely(!__pyx_tuple__202)) __PYX_ERR(2, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__202); + __Pyx_GIVEREF(__pyx_tuple__202); + + /* "src/pyscipopt/lp.pxi":89 + * free(c_inds) + * + * def addCols(self, entrieslist, objs = None, lbs = None, ubs = None): # <<<<<<<<<<<<<< + * """Adds multiple columns to the LP. + * + */ + __pyx_tuple__203 = PyTuple_Pack(19, __pyx_n_s_self, __pyx_n_s_entrieslist, __pyx_n_s_objs, __pyx_n_s_lbs, __pyx_n_s_ubs, __pyx_n_s_ncols, __pyx_n_s_nnonz, __pyx_n_s_c_objs, __pyx_n_s_c_lbs, __pyx_n_s_c_ubs, __pyx_n_s_c_coefs, __pyx_n_s_c_inds, __pyx_n_s_c_beg, __pyx_n_s_tmp, __pyx_n_s_i, __pyx_n_s_entries, __pyx_n_s_entry, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__203)) __PYX_ERR(2, 89, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__203); + __Pyx_GIVEREF(__pyx_tuple__203); + __pyx_codeobj__204 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 19, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__203, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_addCols, 89, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__204)) __PYX_ERR(2, 89, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":144 + * free(c_objs) + * + * def delCols(self, firstcol, lastcol): # <<<<<<<<<<<<<< + * """Deletes a range of columns from the LP. + * + */ + __pyx_tuple__205 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_firstcol, __pyx_n_s_lastcol); if (unlikely(!__pyx_tuple__205)) __PYX_ERR(2, 144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__205); + __Pyx_GIVEREF(__pyx_tuple__205); + __pyx_codeobj__206 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__205, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_delCols, 144, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__206)) __PYX_ERR(2, 144, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":153 + * PY_SCIP_CALL(SCIPlpiDelCols(self.lpi, firstcol, lastcol)) + * + * def addRow(self, entries, lhs=0.0, rhs=None): # <<<<<<<<<<<<<< + * """Adds a single row to the LP. + * + */ + __pyx_tuple__207 = PyTuple_Pack(13, __pyx_n_s_self, __pyx_n_s_entries, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_beg, __pyx_n_s_nnonz, __pyx_n_s_c_coefs, __pyx_n_s_c_inds, __pyx_n_s_c_lhs, __pyx_n_s_c_rhs, __pyx_n_s_c_beg, __pyx_n_s_i, __pyx_n_s_entry); if (unlikely(!__pyx_tuple__207)) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__207); + __Pyx_GIVEREF(__pyx_tuple__207); + __pyx_codeobj__208 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__207, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_addRow, 153, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__208)) __PYX_ERR(2, 153, __pyx_L1_error) + __pyx_tuple__209 = PyTuple_Pack(2, __pyx_float_0_0, Py_None); if (unlikely(!__pyx_tuple__209)) __PYX_ERR(2, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__209); + __Pyx_GIVEREF(__pyx_tuple__209); + + /* "src/pyscipopt/lp.pxi":183 + * free(c_inds) + * + * def addRows(self, entrieslist, lhss = None, rhss = None): # <<<<<<<<<<<<<< + * """Adds multiple rows to the LP. + * + */ + __pyx_tuple__210 = PyTuple_Pack(17, __pyx_n_s_self, __pyx_n_s_entrieslist, __pyx_n_s_lhss, __pyx_n_s_rhss, __pyx_n_s_nrows, __pyx_n_s_nnonz, __pyx_n_s_c_lhss, __pyx_n_s_c_rhss, __pyx_n_s_c_coefs, __pyx_n_s_c_inds, __pyx_n_s_c_beg, __pyx_n_s_tmp, __pyx_n_s_i, __pyx_n_s_entries, __pyx_n_s_entry, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!__pyx_tuple__210)) __PYX_ERR(2, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__210); + __Pyx_GIVEREF(__pyx_tuple__210); + __pyx_codeobj__211 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__210, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_addRows, 183, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__211)) __PYX_ERR(2, 183, __pyx_L1_error) + __pyx_tuple__212 = PyTuple_Pack(2, Py_None, Py_None); if (unlikely(!__pyx_tuple__212)) __PYX_ERR(2, 183, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__212); + __Pyx_GIVEREF(__pyx_tuple__212); + + /* "src/pyscipopt/lp.pxi":219 + * free(c_rhss) + * + * def delRows(self, firstrow, lastrow): # <<<<<<<<<<<<<< + * """Deletes a range of rows from the LP. + * + */ + __pyx_tuple__213 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_firstrow, __pyx_n_s_lastrow); if (unlikely(!__pyx_tuple__213)) __PYX_ERR(2, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__213); + __Pyx_GIVEREF(__pyx_tuple__213); + __pyx_codeobj__214 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__213, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_delRows, 219, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__214)) __PYX_ERR(2, 219, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":228 + * PY_SCIP_CALL(SCIPlpiDelRows(self.lpi, firstrow, lastrow)) + * + * def getBounds(self, firstcol = 0, lastcol = None): # <<<<<<<<<<<<<< + * """Returns all lower and upper bounds for a range of columns. + * + */ + __pyx_tuple__215 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_firstcol, __pyx_n_s_lastcol, __pyx_n_s_ncols, __pyx_n_s_c_lbs, __pyx_n_s_c_ubs, __pyx_n_s_lbs, __pyx_n_s_ubs, __pyx_n_s_i); if (unlikely(!__pyx_tuple__215)) __PYX_ERR(2, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__215); + __Pyx_GIVEREF(__pyx_tuple__215); + __pyx_codeobj__216 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__215, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getBounds, 228, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__216)) __PYX_ERR(2, 228, __pyx_L1_error) + __pyx_tuple__217 = PyTuple_Pack(2, __pyx_int_0, Py_None); if (unlikely(!__pyx_tuple__217)) __PYX_ERR(2, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__217); + __Pyx_GIVEREF(__pyx_tuple__217); + + /* "src/pyscipopt/lp.pxi":257 + * return lbs, ubs + * + * def getSides(self, firstrow = 0, lastrow = None): # <<<<<<<<<<<<<< + * """Returns all left- and right-hand sides for a range of rows. + * + */ + __pyx_tuple__218 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_firstrow, __pyx_n_s_lastrow, __pyx_n_s_nrows, __pyx_n_s_c_lhss, __pyx_n_s_c_rhss, __pyx_n_s_lhss, __pyx_n_s_rhss, __pyx_n_s_i); if (unlikely(!__pyx_tuple__218)) __PYX_ERR(2, 257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__218); + __Pyx_GIVEREF(__pyx_tuple__218); + __pyx_codeobj__219 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__218, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getSides, 257, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__219)) __PYX_ERR(2, 257, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":286 + * return lhss, rhss + * + * def chgObj(self, col, obj): # <<<<<<<<<<<<<< + * """Changes objective coefficient of a single column. + * + */ + __pyx_tuple__220 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_col, __pyx_n_s_obj, __pyx_n_s_c_col, __pyx_n_s_c_obj); if (unlikely(!__pyx_tuple__220)) __PYX_ERR(2, 286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__220); + __Pyx_GIVEREF(__pyx_tuple__220); + __pyx_codeobj__221 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__220, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_chgObj, 286, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__221)) __PYX_ERR(2, 286, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":297 + * PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj)) + * + * def chgCoef(self, row, col, newval): # <<<<<<<<<<<<<< + * """Changes a single coefficient in the LP. + * + */ + __pyx_tuple__222 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_row, __pyx_n_s_col, __pyx_n_s_newval); if (unlikely(!__pyx_tuple__222)) __PYX_ERR(2, 297, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__222); + __Pyx_GIVEREF(__pyx_tuple__222); + __pyx_codeobj__223 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__222, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_chgCoef, 297, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__223)) __PYX_ERR(2, 297, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":307 + * PY_SCIP_CALL(SCIPlpiChgCoef(self.lpi, row, col, newval)) + * + * def chgBound(self, col, lb, ub): # <<<<<<<<<<<<<< + * """Changes the lower and upper bound of a single column. + * + */ + __pyx_tuple__224 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_col, __pyx_n_s_lb, __pyx_n_s_ub, __pyx_n_s_c_col, __pyx_n_s_c_lb, __pyx_n_s_c_ub); if (unlikely(!__pyx_tuple__224)) __PYX_ERR(2, 307, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__224); + __Pyx_GIVEREF(__pyx_tuple__224); + __pyx_codeobj__225 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__224, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_chgBound, 307, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__225)) __PYX_ERR(2, 307, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":320 + * PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub)) + * + * def chgSide(self, row, lhs, rhs): # <<<<<<<<<<<<<< + * """Changes the left- and right-hand side of a single row. + * + */ + __pyx_tuple__226 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_row, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_c_row, __pyx_n_s_c_lhs, __pyx_n_s_c_rhs); if (unlikely(!__pyx_tuple__226)) __PYX_ERR(2, 320, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__226); + __Pyx_GIVEREF(__pyx_tuple__226); + __pyx_codeobj__227 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__226, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_chgSide, 320, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__227)) __PYX_ERR(2, 320, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":333 + * PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs)) + * + * def clear(self): # <<<<<<<<<<<<<< + * """Clears the whole LP.""" + * PY_SCIP_CALL(SCIPlpiClear(self.lpi)) + */ + __pyx_codeobj__228 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_clear, 333, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__228)) __PYX_ERR(2, 333, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":337 + * PY_SCIP_CALL(SCIPlpiClear(self.lpi)) + * + * def nrows(self): # <<<<<<<<<<<<<< + * """Returns the number of rows.""" + * cdef int nrows + */ + __pyx_tuple__229 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_nrows); if (unlikely(!__pyx_tuple__229)) __PYX_ERR(2, 337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__229); + __Pyx_GIVEREF(__pyx_tuple__229); + __pyx_codeobj__230 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__229, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_nrows, 337, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__230)) __PYX_ERR(2, 337, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":343 + * return nrows + * + * def ncols(self): # <<<<<<<<<<<<<< + * """Returns the number of columns.""" + * cdef int ncols + */ + __pyx_tuple__231 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_ncols); if (unlikely(!__pyx_tuple__231)) __PYX_ERR(2, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__231); + __Pyx_GIVEREF(__pyx_tuple__231); + __pyx_codeobj__232 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__231, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_ncols, 343, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__232)) __PYX_ERR(2, 343, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":349 + * return ncols + * + * def solve(self, dual=True): # <<<<<<<<<<<<<< + * """Solves the current LP. + * + */ + __pyx_tuple__233 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_dual, __pyx_n_s_objval); if (unlikely(!__pyx_tuple__233)) __PYX_ERR(2, 349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__233); + __Pyx_GIVEREF(__pyx_tuple__233); + __pyx_codeobj__234 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__233, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_solve, 349, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__234)) __PYX_ERR(2, 349, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":364 + * return objval + * + * def getPrimal(self): # <<<<<<<<<<<<<< + * """Returns the primal solution of the last LP solve.""" + * ncols = self.ncols() + */ + __pyx_tuple__235 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_ncols, __pyx_n_s_c_primalsol, __pyx_n_s_primalsol, __pyx_n_s_i); if (unlikely(!__pyx_tuple__235)) __PYX_ERR(2, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__235); + __Pyx_GIVEREF(__pyx_tuple__235); + __pyx_codeobj__236 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__235, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getPrimal, 364, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__236)) __PYX_ERR(2, 364, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":376 + * return primalsol + * + * def isPrimalFeasible(self): # <<<<<<<<<<<<<< + * """Returns True iff LP is proven to be primal feasible.""" + * return SCIPlpiIsPrimalFeasible(self.lpi) + */ + __pyx_codeobj__237 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_isPrimalFeasible, 376, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__237)) __PYX_ERR(2, 376, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":380 + * return SCIPlpiIsPrimalFeasible(self.lpi) + * + * def getDual(self): # <<<<<<<<<<<<<< + * """Returns the dual solution of the last LP solve.""" + * nrows = self.nrows() + */ + __pyx_tuple__238 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_nrows, __pyx_n_s_c_dualsol, __pyx_n_s_dualsol, __pyx_n_s_i); if (unlikely(!__pyx_tuple__238)) __PYX_ERR(2, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__238); + __Pyx_GIVEREF(__pyx_tuple__238); + __pyx_codeobj__239 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__238, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getDual, 380, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__239)) __PYX_ERR(2, 380, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":392 + * return dualsol + * + * def isDualFeasible(self): # <<<<<<<<<<<<<< + * """Returns True iff LP is proven to be dual feasible.""" + * return SCIPlpiIsDualFeasible(self.lpi) + */ + __pyx_codeobj__240 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_isDualFeasible, 392, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__240)) __PYX_ERR(2, 392, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":396 + * return SCIPlpiIsDualFeasible(self.lpi) + * + * def getPrimalRay(self): # <<<<<<<<<<<<<< + * """Returns a primal ray if possible, None otherwise.""" + * if not SCIPlpiHasPrimalRay(self.lpi): + */ + __pyx_tuple__241 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_ncols, __pyx_n_s_c_ray, __pyx_n_s_ray, __pyx_n_s_i); if (unlikely(!__pyx_tuple__241)) __PYX_ERR(2, 396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__241); + __Pyx_GIVEREF(__pyx_tuple__241); + __pyx_codeobj__242 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__241, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getPrimalRay, 396, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__242)) __PYX_ERR(2, 396, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":410 + * return ray + * + * def getDualRay(self): # <<<<<<<<<<<<<< + * """Returns a dual ray if possible, None otherwise.""" + * if not SCIPlpiHasDualRay(self.lpi): + */ + __pyx_tuple__243 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_nrows, __pyx_n_s_c_ray, __pyx_n_s_ray, __pyx_n_s_i); if (unlikely(!__pyx_tuple__243)) __PYX_ERR(2, 410, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__243); + __Pyx_GIVEREF(__pyx_tuple__243); + __pyx_codeobj__244 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__243, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getDualRay, 410, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__244)) __PYX_ERR(2, 410, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":424 + * return ray + * + * def getNIterations(self): # <<<<<<<<<<<<<< + * """Returns the number of LP iterations of the last LP solve.""" + * cdef int niters + */ + __pyx_tuple__245 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_niters); if (unlikely(!__pyx_tuple__245)) __PYX_ERR(2, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__245); + __Pyx_GIVEREF(__pyx_tuple__245); + __pyx_codeobj__246 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__245, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getNIterations, 424, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__246)) __PYX_ERR(2, 424, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":430 + * return niters + * + * def getRedcost(self): # <<<<<<<<<<<<<< + * """Returns the reduced cost vector of the last LP solve.""" + * ncols = self.ncols() + */ + __pyx_tuple__247 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_ncols, __pyx_n_s_c_redcost, __pyx_n_s_redcost, __pyx_n_s_i); if (unlikely(!__pyx_tuple__247)) __PYX_ERR(2, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__247); + __Pyx_GIVEREF(__pyx_tuple__247); + __pyx_codeobj__248 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__247, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getRedcost, 430, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__248)) __PYX_ERR(2, 430, __pyx_L1_error) + + /* "src/pyscipopt/lp.pxi":444 + * return redcost + * + * def getBasisInds(self): # <<<<<<<<<<<<<< + * """Returns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * nrows = self.nrows() + */ + __pyx_tuple__249 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_nrows, __pyx_n_s_c_binds, __pyx_n_s_binds, __pyx_n_s_i); if (unlikely(!__pyx_tuple__249)) __PYX_ERR(2, 444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__249); + __Pyx_GIVEREF(__pyx_tuple__249); + __pyx_codeobj__250 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__249, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_lp_pxi, __pyx_n_s_getBasisInds, 444, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__250)) __PYX_ERR(2, 444, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__251 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__251)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.lpi cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__252 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__252)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":8 + * cdef SCIP_BENDERS* _benders + * + * def bendersfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of Benders decomposition ''' + * pass + */ + __pyx_codeobj__253 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersfree, 8, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__253)) __PYX_ERR(3, 8, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":12 + * pass + * + * def bendersinit(self): # <<<<<<<<<<<<<< + * '''initializes Benders deconposition''' + * pass + */ + __pyx_codeobj__254 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersinit, 12, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__254)) __PYX_ERR(3, 12, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":16 + * pass + * + * def bendersexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of Benders decomposition''' + * pass + */ + __pyx_codeobj__255 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersexit, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__255)) __PYX_ERR(3, 16, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":20 + * pass + * + * def bendersinitpre(self): # <<<<<<<<<<<<<< + * '''informs the Benders decomposition that the presolving process is being started ''' + * pass + */ + __pyx_codeobj__256 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersinitpre, 20, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__256)) __PYX_ERR(3, 20, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":24 + * pass + * + * def bendersexitpre(self): # <<<<<<<<<<<<<< + * '''informs the Benders decomposition that the presolving process has been completed''' + * pass + */ + __pyx_codeobj__257 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersexitpre, 24, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__257)) __PYX_ERR(3, 24, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":28 + * pass + * + * def bendersinitsol(self): # <<<<<<<<<<<<<< + * '''informs Benders decomposition that the branch and bound process is being started ''' + * pass + */ + __pyx_codeobj__258 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersinitsol, 28, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__258)) __PYX_ERR(3, 28, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":32 + * pass + * + * def bendersexitsol(self): # <<<<<<<<<<<<<< + * '''informs Benders decomposition that the branch and bound process data is being freed''' + * pass + */ + __pyx_codeobj__259 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersexitsol, 32, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__259)) __PYX_ERR(3, 32, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":36 + * pass + * + * def benderscreatesub(self, probnumber): # <<<<<<<<<<<<<< + * '''creates the subproblems and registers it with the Benders decomposition struct ''' + * print("python error in benderscreatesub: this method needs to be implemented") + */ + __pyx_tuple__260 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_probnumber); if (unlikely(!__pyx_tuple__260)) __PYX_ERR(3, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__260); + __Pyx_GIVEREF(__pyx_tuple__260); + __pyx_codeobj__261 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__260, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_benderscreatesub, 36, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__261)) __PYX_ERR(3, 36, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":41 + * return {} + * + * def benderspresubsolve(self, solution, enfotype, checkint): # <<<<<<<<<<<<<< + * '''sets the pre subproblem solve callback of Benders decomposition ''' + * return {} + */ + __pyx_tuple__262 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_enfotype, __pyx_n_s_checkint); if (unlikely(!__pyx_tuple__262)) __PYX_ERR(3, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__262); + __Pyx_GIVEREF(__pyx_tuple__262); + __pyx_codeobj__263 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__262, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_benderspresubsolve, 41, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__263)) __PYX_ERR(3, 41, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":45 + * return {} + * + * def benderssolvesubconvex(self, solution, probnumber, onlyconvex): # <<<<<<<<<<<<<< + * '''sets convex solve callback of Benders decomposition''' + * return {} + */ + __pyx_tuple__264 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_probnumber, __pyx_n_s_onlyconvex); if (unlikely(!__pyx_tuple__264)) __PYX_ERR(3, 45, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__264); + __Pyx_GIVEREF(__pyx_tuple__264); + __pyx_codeobj__265 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__264, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_benderssolvesubconvex, 45, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__265)) __PYX_ERR(3, 45, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":49 + * return {} + * + * def benderssolvesub(self, solution, probnumber): # <<<<<<<<<<<<<< + * '''sets solve callback of Benders decomposition ''' + * return {} + */ + __pyx_tuple__266 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_probnumber); if (unlikely(!__pyx_tuple__266)) __PYX_ERR(3, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__266); + __Pyx_GIVEREF(__pyx_tuple__266); + __pyx_codeobj__267 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__266, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_benderssolvesub, 49, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__267)) __PYX_ERR(3, 49, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":53 + * return {} + * + * def benderspostsolve(self, solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible): # <<<<<<<<<<<<<< + * '''sets post-solve callback of Benders decomposition ''' + * return {} + */ + __pyx_tuple__268 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_enfotype, __pyx_n_s_mergecandidates, __pyx_n_s_npriomergecands, __pyx_n_s_checkint, __pyx_n_s_infeasible); if (unlikely(!__pyx_tuple__268)) __PYX_ERR(3, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__268); + __Pyx_GIVEREF(__pyx_tuple__268); + __pyx_codeobj__269 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__268, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_benderspostsolve, 53, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__269)) __PYX_ERR(3, 53, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":57 + * return {} + * + * def bendersfreesub(self, probnumber): # <<<<<<<<<<<<<< + * '''frees the subproblems''' + * pass + */ + __pyx_codeobj__270 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__260, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersfreesub, 57, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__270)) __PYX_ERR(3, 57, __pyx_L1_error) + + /* "src/pyscipopt/benders.pxi":61 + * pass + * + * def bendersgetvar(self, variable, probnumber): # <<<<<<<<<<<<<< + * '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. ''' + * print("python error in bendersgetvar: this method needs to be implemented") + */ + __pyx_tuple__271 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_variable, __pyx_n_s_probnumber); if (unlikely(!__pyx_tuple__271)) __PYX_ERR(3, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__271); + __Pyx_GIVEREF(__pyx_tuple__271); + __pyx_codeobj__272 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__271, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benders_pxi, __pyx_n_s_bendersgetvar, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__272)) __PYX_ERR(3, 61, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__273 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__273)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self._benders cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__274 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__274)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/benderscut.pxi":8 + * cdef public str name + * + * def benderscutfree(self): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_codeobj__275 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benderscut_pxi, __pyx_n_s_benderscutfree, 8, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__275)) __PYX_ERR(7, 8, __pyx_L1_error) + + /* "src/pyscipopt/benderscut.pxi":11 + * pass + * + * def benderscutinit(self): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_codeobj__276 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benderscut_pxi, __pyx_n_s_benderscutinit, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__276)) __PYX_ERR(7, 11, __pyx_L1_error) + + /* "src/pyscipopt/benderscut.pxi":14 + * pass + * + * def benderscutexit(self): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_codeobj__277 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benderscut_pxi, __pyx_n_s_benderscutexit, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__277)) __PYX_ERR(7, 14, __pyx_L1_error) + + /* "src/pyscipopt/benderscut.pxi":17 + * pass + * + * def benderscutinitsol(self): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_codeobj__278 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benderscut_pxi, __pyx_n_s_benderscutinitsol, 17, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__278)) __PYX_ERR(7, 17, __pyx_L1_error) + + /* "src/pyscipopt/benderscut.pxi":20 + * pass + * + * def benderscutexitsol(self): # <<<<<<<<<<<<<< + * pass + * + */ + __pyx_codeobj__279 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benderscut_pxi, __pyx_n_s_benderscutexitsol, 20, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__279)) __PYX_ERR(7, 20, __pyx_L1_error) + + /* "src/pyscipopt/benderscut.pxi":23 + * pass + * + * def benderscutexec(self, solution, probnumber, enfotype): # <<<<<<<<<<<<<< + * print("python error in benderscutexec: this method needs to be implemented") + * return {} + */ + __pyx_tuple__280 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_probnumber, __pyx_n_s_enfotype); if (unlikely(!__pyx_tuple__280)) __PYX_ERR(7, 23, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__280); + __Pyx_GIVEREF(__pyx_tuple__280); + __pyx_codeobj__281 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__280, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_benderscut_pxi, __pyx_n_s_benderscutexec, 23, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__281)) __PYX_ERR(7, 23, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__282 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__282)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Benderscut__set_state(self, __pyx_state) + */ + __pyx_codeobj__283 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__283)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":6 + * cdef public Model model + * + * def branchfree(self): # <<<<<<<<<<<<<< + * '''frees memory of branching rule''' + * pass + */ + __pyx_codeobj__284 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_n_s_branchfree, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__284)) __PYX_ERR(8, 6, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":10 + * pass + * + * def branchinit(self): # <<<<<<<<<<<<<< + * '''initializes branching rule''' + * pass + */ + __pyx_codeobj__285 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_n_s_branchinit, 10, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__285)) __PYX_ERR(8, 10, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":14 + * pass + * + * def branchexit(self): # <<<<<<<<<<<<<< + * '''deinitializes branching rule''' + * pass + */ + __pyx_codeobj__286 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_n_s_branchexit, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__286)) __PYX_ERR(8, 14, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":18 + * pass + * + * def branchinitsol(self): # <<<<<<<<<<<<<< + * '''informs branching rule that the branch and bound process is being started ''' + * pass + */ + __pyx_codeobj__287 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_n_s_branchinitsol, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__287)) __PYX_ERR(8, 18, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":22 + * pass + * + * def branchexitsol(self): # <<<<<<<<<<<<<< + * '''informs branching rule that the branch and bound process data is being freed''' + * pass + */ + __pyx_codeobj__288 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_n_s_branchexitsol, 22, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__288)) __PYX_ERR(8, 22, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":26 + * pass + * + * def branchexeclp(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for fractional LP solution''' + * raise NotImplementedError("branchexeclp() is a fundamental callback and should be implemented in the derived " + */ + __pyx_tuple__289 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_allowaddcons); if (unlikely(!__pyx_tuple__289)) __PYX_ERR(8, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__289); + __Pyx_GIVEREF(__pyx_tuple__289); + __pyx_codeobj__290 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__289, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_n_s_branchexeclp, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__290)) __PYX_ERR(8, 26, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":31 + * "class") + * + * def branchexecext(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for external branching candidates ''' + * raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") + */ + __pyx_codeobj__291 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__289, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_n_s_branchexecext, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__291)) __PYX_ERR(8, 31, __pyx_L1_error) + + /* "src/pyscipopt/branchrule.pxi":35 + * raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class") + * + * def branchexecps(self, allowaddcons): # <<<<<<<<<<<<<< + * '''executes branching rule for not completely fixed pseudo solution ''' + * # this method needs to be implemented by the user + */ + __pyx_codeobj__292 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__289, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_branchrule_pxi, __pyx_n_s_branchexecps, 35, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__292)) __PYX_ERR(8, 35, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__293 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__293)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Branchrule__set_state(self, __pyx_state) + */ + __pyx_codeobj__294 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__294)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":8 + * cdef public str name + * + * def consfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of constraint handler ''' + * pass + */ + __pyx_codeobj__295 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consfree, 8, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__295)) __PYX_ERR(9, 8, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":12 + * pass + * + * def consinit(self, constraints): # <<<<<<<<<<<<<< + * '''calls initialization method of constraint handler ''' + * pass + */ + __pyx_tuple__296 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_constraints); if (unlikely(!__pyx_tuple__296)) __PYX_ERR(9, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__296); + __Pyx_GIVEREF(__pyx_tuple__296); + __pyx_codeobj__297 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__296, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consinit, 12, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__297)) __PYX_ERR(9, 12, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":16 + * pass + * + * def consexit(self, constraints): # <<<<<<<<<<<<<< + * '''calls exit method of constraint handler ''' + * pass + */ + __pyx_codeobj__298 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__296, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consexit, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__298)) __PYX_ERR(9, 16, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":20 + * pass + * + * def consinitpre(self, constraints): # <<<<<<<<<<<<<< + * '''informs constraint handler that the presolving process is being started ''' + * pass + */ + __pyx_codeobj__299 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__296, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consinitpre, 20, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__299)) __PYX_ERR(9, 20, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":24 + * pass + * + * def consexitpre(self, constraints): # <<<<<<<<<<<<<< + * '''informs constraint handler that the presolving is finished ''' + * pass + */ + __pyx_codeobj__300 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__296, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consexitpre, 24, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__300)) __PYX_ERR(9, 24, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":28 + * pass + * + * def consinitsol(self, constraints): # <<<<<<<<<<<<<< + * '''informs constraint handler that the branch and bound process is being started ''' + * pass + */ + __pyx_codeobj__301 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__296, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consinitsol, 28, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__301)) __PYX_ERR(9, 28, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":32 + * pass + * + * def consexitsol(self, constraints, restart): # <<<<<<<<<<<<<< + * '''informs constraint handler that the branch and bound process data is being freed ''' + * pass + */ + __pyx_tuple__302 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_constraints, __pyx_n_s_restart); if (unlikely(!__pyx_tuple__302)) __PYX_ERR(9, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__302); + __Pyx_GIVEREF(__pyx_tuple__302); + __pyx_codeobj__303 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__302, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consexitsol, 32, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__303)) __PYX_ERR(9, 32, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":36 + * pass + * + * def consdelete(self, constraint): # <<<<<<<<<<<<<< + * '''sets method of constraint handler to free specific constraint data ''' + * pass + */ + __pyx_tuple__304 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_constraint); if (unlikely(!__pyx_tuple__304)) __PYX_ERR(9, 36, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__304); + __Pyx_GIVEREF(__pyx_tuple__304); + __pyx_codeobj__305 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consdelete, 36, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__305)) __PYX_ERR(9, 36, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":40 + * pass + * + * def constrans(self, sourceconstraint): # <<<<<<<<<<<<<< + * '''sets method of constraint handler to transform constraint data into data belonging to the transformed problem ''' + * return {} + */ + __pyx_tuple__306 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_sourceconstraint); if (unlikely(!__pyx_tuple__306)) __PYX_ERR(9, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__306); + __Pyx_GIVEREF(__pyx_tuple__306); + __pyx_codeobj__307 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__306, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_constrans, 40, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__307)) __PYX_ERR(9, 40, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":44 + * return {} + * + * def consinitlp(self, constraints): # <<<<<<<<<<<<<< + * '''calls LP initialization method of constraint handler to separate all initial active constraints ''' + * return {} + */ + __pyx_codeobj__308 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__296, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consinitlp, 44, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__308)) __PYX_ERR(9, 44, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":48 + * return {} + * + * def conssepalp(self, constraints, nusefulconss): # <<<<<<<<<<<<<< + * '''calls separator method of constraint handler to separate LP solution ''' + * return {} + */ + __pyx_tuple__309 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_constraints, __pyx_n_s_nusefulconss); if (unlikely(!__pyx_tuple__309)) __PYX_ERR(9, 48, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__309); + __Pyx_GIVEREF(__pyx_tuple__309); + __pyx_codeobj__310 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__309, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_conssepalp, 48, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__310)) __PYX_ERR(9, 48, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":52 + * return {} + * + * def conssepasol(self, constraints, nusefulconss, solution): # <<<<<<<<<<<<<< + * '''calls separator method of constraint handler to separate given primal solution ''' + * return {} + */ + __pyx_tuple__311 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_constraints, __pyx_n_s_nusefulconss, __pyx_n_s_solution); if (unlikely(!__pyx_tuple__311)) __PYX_ERR(9, 52, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__311); + __Pyx_GIVEREF(__pyx_tuple__311); + __pyx_codeobj__312 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__311, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_conssepasol, 52, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__312)) __PYX_ERR(9, 52, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":56 + * return {} + * + * def consenfolp(self, constraints, nusefulconss, solinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for LP solution for all constraints added''' + * print("python error in consenfolp: this method needs to be implemented") + */ + __pyx_tuple__313 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_constraints, __pyx_n_s_nusefulconss, __pyx_n_s_solinfeasible); if (unlikely(!__pyx_tuple__313)) __PYX_ERR(9, 56, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__313); + __Pyx_GIVEREF(__pyx_tuple__313); + __pyx_codeobj__314 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__313, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consenfolp, 56, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__314)) __PYX_ERR(9, 56, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":61 + * return {} + * + * def consenforelax(self, solution, constraints, nusefulconss, solinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for a relaxation solution for all constraints added''' + * print("python error in consenforelax: this method needs to be implemented") + */ + __pyx_tuple__315 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_constraints, __pyx_n_s_nusefulconss, __pyx_n_s_solinfeasible); if (unlikely(!__pyx_tuple__315)) __PYX_ERR(9, 61, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__315); + __Pyx_GIVEREF(__pyx_tuple__315); + __pyx_codeobj__316 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__315, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consenforelax, 61, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__316)) __PYX_ERR(9, 61, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":66 + * return {} + * + * def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible): # <<<<<<<<<<<<<< + * '''calls enforcing method of constraint handler for pseudo solution for all constraints added''' + * print("python error in consenfops: this method needs to be implemented") + */ + __pyx_tuple__317 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_constraints, __pyx_n_s_nusefulconss, __pyx_n_s_solinfeasible, __pyx_n_s_objinfeasible); if (unlikely(!__pyx_tuple__317)) __PYX_ERR(9, 66, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__317); + __Pyx_GIVEREF(__pyx_tuple__317); + __pyx_codeobj__318 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__317, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consenfops, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__318)) __PYX_ERR(9, 66, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":71 + * return {} + * + * def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely): # <<<<<<<<<<<<<< + * '''calls feasibility check method of constraint handler ''' + * print("python error in conscheck: this method needs to be implemented") + */ + __pyx_tuple__319 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_constraints, __pyx_n_s_solution, __pyx_n_s_checkintegrality, __pyx_n_s_checklprows, __pyx_n_s_printreason, __pyx_n_s_completely); if (unlikely(!__pyx_tuple__319)) __PYX_ERR(9, 71, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__319); + __Pyx_GIVEREF(__pyx_tuple__319); + __pyx_codeobj__320 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__319, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_conscheck, 71, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__320)) __PYX_ERR(9, 71, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":76 + * return {} + * + * def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming): # <<<<<<<<<<<<<< + * '''calls propagation method of constraint handler ''' + * return {} + */ + __pyx_tuple__321 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_constraints, __pyx_n_s_nusefulconss, __pyx_n_s_nmarkedconss, __pyx_n_s_proptiming); if (unlikely(!__pyx_tuple__321)) __PYX_ERR(9, 76, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__321); + __Pyx_GIVEREF(__pyx_tuple__321); + __pyx_codeobj__322 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__321, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consprop, 76, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__322)) __PYX_ERR(9, 76, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":80 + * return {} + * + * def conspresol(self, constraints, nrounds, presoltiming, # <<<<<<<<<<<<<< + * nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes, + * nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict): + */ + __pyx_tuple__323 = PyTuple_Pack(15, __pyx_n_s_self, __pyx_n_s_constraints, __pyx_n_s_nrounds, __pyx_n_s_presoltiming, __pyx_n_s_nnewfixedvars, __pyx_n_s_nnewaggrvars, __pyx_n_s_nnewchgvartypes, __pyx_n_s_nnewchgbds, __pyx_n_s_nnewholes, __pyx_n_s_nnewdelconss, __pyx_n_s_nnewaddconss, __pyx_n_s_nnewupgdconss, __pyx_n_s_nnewchgcoefs, __pyx_n_s_nnewchgsides, __pyx_n_s_result_dict); if (unlikely(!__pyx_tuple__323)) __PYX_ERR(9, 80, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__323); + __Pyx_GIVEREF(__pyx_tuple__323); + __pyx_codeobj__324 = (PyObject*)__Pyx_PyCode_New(15, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__323, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_conspresol, 80, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__324)) __PYX_ERR(9, 80, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":86 + * return result_dict + * + * def consresprop(self): # <<<<<<<<<<<<<< + * '''sets propagation conflict resolving method of constraint handler ''' + * return {} + */ + __pyx_codeobj__325 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consresprop, 86, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__325)) __PYX_ERR(9, 86, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":90 + * return {} + * + * def conslock(self, constraint, locktype, nlockspos, nlocksneg): # <<<<<<<<<<<<<< + * '''variable rounding lock method of constraint handler''' + * print("python error in conslock: this method needs to be implemented") + */ + __pyx_tuple__326 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_constraint, __pyx_n_s_locktype, __pyx_n_s_nlockspos, __pyx_n_s_nlocksneg); if (unlikely(!__pyx_tuple__326)) __PYX_ERR(9, 90, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__326); + __Pyx_GIVEREF(__pyx_tuple__326); + __pyx_codeobj__327 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__326, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_conslock, 90, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__327)) __PYX_ERR(9, 90, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":95 + * return {} + * + * def consactive(self, constraint): # <<<<<<<<<<<<<< + * '''sets activation notification method of constraint handler ''' + * pass + */ + __pyx_codeobj__328 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consactive, 95, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__328)) __PYX_ERR(9, 95, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":99 + * pass + * + * def consdeactive(self, constraint): # <<<<<<<<<<<<<< + * '''sets deactivation notification method of constraint handler ''' + * pass + */ + __pyx_codeobj__329 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consdeactive, 99, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__329)) __PYX_ERR(9, 99, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":103 + * pass + * + * def consenable(self, constraint): # <<<<<<<<<<<<<< + * '''sets enabling notification method of constraint handler ''' + * pass + */ + __pyx_codeobj__330 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consenable, 103, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__330)) __PYX_ERR(9, 103, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":107 + * pass + * + * def consdisable(self, constraint): # <<<<<<<<<<<<<< + * '''sets disabling notification method of constraint handler ''' + * pass + */ + __pyx_codeobj__331 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consdisable, 107, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__331)) __PYX_ERR(9, 107, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":111 + * pass + * + * def consdelvars(self, constraints): # <<<<<<<<<<<<<< + * '''calls variable deletion method of constraint handler''' + * pass + */ + __pyx_codeobj__332 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__296, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consdelvars, 111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__332)) __PYX_ERR(9, 111, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":115 + * pass + * + * def consprint(self, constraint): # <<<<<<<<<<<<<< + * '''sets constraint display method of constraint handler ''' + * pass + */ + __pyx_codeobj__333 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consprint, 115, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__333)) __PYX_ERR(9, 115, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":119 + * pass + * + * def conscopy(self): # <<<<<<<<<<<<<< + * '''sets copy method of both the constraint handler and each associated constraint''' + * pass + */ + __pyx_codeobj__334 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_conscopy, 119, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__334)) __PYX_ERR(9, 119, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":123 + * pass + * + * def consparse(self): # <<<<<<<<<<<<<< + * '''sets constraint parsing method of constraint handler ''' + * pass + */ + __pyx_codeobj__335 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consparse, 123, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__335)) __PYX_ERR(9, 123, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":127 + * pass + * + * def consgetvars(self, constraint): # <<<<<<<<<<<<<< + * '''sets constraint variable getter method of constraint handler''' + * pass + */ + __pyx_codeobj__336 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consgetvars, 127, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__336)) __PYX_ERR(9, 127, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":131 + * pass + * + * def consgetnvars(self, constraint): # <<<<<<<<<<<<<< + * '''sets constraint variable number getter method of constraint handler ''' + * return {} + */ + __pyx_codeobj__337 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consgetnvars, 131, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__337)) __PYX_ERR(9, 131, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":135 + * return {} + * + * def consgetdivebdchgs(self): # <<<<<<<<<<<<<< + * '''calls diving solution enforcement callback of constraint handler, if it exists ''' + * pass + */ + __pyx_codeobj__338 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consgetdivebdchgs, 135, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__338)) __PYX_ERR(9, 135, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":139 + * pass + * + * def consgetpermsymgraph(self): # <<<<<<<<<<<<<< + * '''permutation symmetry detection graph getter callback, if it exists ''' + * pass + */ + __pyx_codeobj__339 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consgetpermsymgraph, 139, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__339)) __PYX_ERR(9, 139, __pyx_L1_error) + + /* "src/pyscipopt/conshdlr.pxi":143 + * pass + * + * def consgetsignedpermsymgraph(self): # <<<<<<<<<<<<<< + * '''signed permutation symmetry detection graph getter callback, if it exists ''' + * pass + */ + __pyx_codeobj__340 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_conshdlr_pxi, __pyx_n_s_consgetsignedpermsymgraph, 143, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__340)) __PYX_ERR(9, 143, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__341 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__341)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Conshdlr__set_state(self, __pyx_state) + */ + __pyx_codeobj__342 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__342)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/cutsel.pxi":6 + * cdef public Model model + * + * def cutselfree(self): # <<<<<<<<<<<<<< + * '''frees memory of cut selector''' + * pass + */ + __pyx_codeobj__343 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_cutsel_pxi, __pyx_n_s_cutselfree, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__343)) __PYX_ERR(10, 6, __pyx_L1_error) + + /* "src/pyscipopt/cutsel.pxi":10 + * pass + * + * def cutselinit(self): # <<<<<<<<<<<<<< + * ''' executed after the problem is transformed. use this call to initialize cut selector data.''' + * pass + */ + __pyx_codeobj__344 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_cutsel_pxi, __pyx_n_s_cutselinit, 10, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__344)) __PYX_ERR(10, 10, __pyx_L1_error) + + /* "src/pyscipopt/cutsel.pxi":14 + * pass + * + * def cutselexit(self): # <<<<<<<<<<<<<< + * '''executed before the transformed problem is freed''' + * pass + */ + __pyx_codeobj__345 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_cutsel_pxi, __pyx_n_s_cutselexit, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__345)) __PYX_ERR(10, 14, __pyx_L1_error) + + /* "src/pyscipopt/cutsel.pxi":18 + * pass + * + * def cutselinitsol(self): # <<<<<<<<<<<<<< + * '''executed when the presolving is finished and the branch-and-bound process is about to begin''' + * pass + */ + __pyx_codeobj__346 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_cutsel_pxi, __pyx_n_s_cutselinitsol, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__346)) __PYX_ERR(10, 18, __pyx_L1_error) + + /* "src/pyscipopt/cutsel.pxi":22 + * pass + * + * def cutselexitsol(self): # <<<<<<<<<<<<<< + * '''executed before the branch-and-bound process is freed''' + * pass + */ + __pyx_codeobj__347 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_cutsel_pxi, __pyx_n_s_cutselexitsol, 22, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__347)) __PYX_ERR(10, 22, __pyx_L1_error) + + /* "src/pyscipopt/cutsel.pxi":26 + * pass + * + * def cutselselect(self, cuts, forcedcuts, root, maxnselectedcuts): # <<<<<<<<<<<<<< + * '''first method called in each iteration in the main solving loop. ''' + * # this method needs to be implemented by the user + */ + __pyx_tuple__348 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_cuts, __pyx_n_s_forcedcuts, __pyx_n_s_root, __pyx_n_s_maxnselectedcuts); if (unlikely(!__pyx_tuple__348)) __PYX_ERR(10, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__348); + __Pyx_GIVEREF(__pyx_tuple__348); + __pyx_codeobj__349 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__348, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_cutsel_pxi, __pyx_n_s_cutselselect, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__349)) __PYX_ERR(10, 26, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__350 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__350)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Cutsel__set_state(self, __pyx_state) + */ + __pyx_codeobj__351 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__351)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/event.pxi":7 + * cdef public str name + * + * def eventcopy(self): # <<<<<<<<<<<<<< + * '''sets copy callback for all events of this event handler ''' + * pass + */ + __pyx_codeobj__352 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_event_pxi, __pyx_n_s_eventcopy, 7, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__352)) __PYX_ERR(11, 7, __pyx_L1_error) + + /* "src/pyscipopt/event.pxi":11 + * pass + * + * def eventfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of event handler ''' + * pass + */ + __pyx_codeobj__353 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_event_pxi, __pyx_n_s_eventfree, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__353)) __PYX_ERR(11, 11, __pyx_L1_error) + + /* "src/pyscipopt/event.pxi":15 + * pass + * + * def eventinit(self): # <<<<<<<<<<<<<< + * '''initializes event handler''' + * pass + */ + __pyx_codeobj__354 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_event_pxi, __pyx_n_s_eventinit, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__354)) __PYX_ERR(11, 15, __pyx_L1_error) + + /* "src/pyscipopt/event.pxi":19 + * pass + * + * def eventexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of event handler''' + * pass + */ + __pyx_codeobj__355 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_event_pxi, __pyx_n_s_eventexit, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__355)) __PYX_ERR(11, 19, __pyx_L1_error) + + /* "src/pyscipopt/event.pxi":23 + * pass + * + * def eventinitsol(self): # <<<<<<<<<<<<<< + * '''informs event handler that the branch and bound process is being started ''' + * pass + */ + __pyx_codeobj__356 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_event_pxi, __pyx_n_s_eventinitsol, 23, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__356)) __PYX_ERR(11, 23, __pyx_L1_error) + + /* "src/pyscipopt/event.pxi":27 + * pass + * + * def eventexitsol(self): # <<<<<<<<<<<<<< + * '''informs event handler that the branch and bound process data is being freed ''' + * pass + */ + __pyx_codeobj__357 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_event_pxi, __pyx_n_s_eventexitsol, 27, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__357)) __PYX_ERR(11, 27, __pyx_L1_error) + + /* "src/pyscipopt/event.pxi":31 + * pass + * + * def eventdelete(self): # <<<<<<<<<<<<<< + * '''sets callback to free specific event data''' + * pass + */ + __pyx_codeobj__358 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_event_pxi, __pyx_n_s_eventdelete, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__358)) __PYX_ERR(11, 31, __pyx_L1_error) + + /* "src/pyscipopt/event.pxi":35 + * pass + * + * def eventexec(self, event): # <<<<<<<<<<<<<< + * '''calls execution method of event handler ''' + * print("python error in eventexec: this method needs to be implemented") + */ + __pyx_tuple__359 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_event); if (unlikely(!__pyx_tuple__359)) __PYX_ERR(11, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__359); + __Pyx_GIVEREF(__pyx_tuple__359); + __pyx_codeobj__360 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__359, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_event_pxi, __pyx_n_s_eventexec, 35, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__360)) __PYX_ERR(11, 35, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__361 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__361)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Eventhdlr__set_state(self, __pyx_state) + */ + __pyx_codeobj__362 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__362)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/heuristic.pxi":7 + * cdef public str name + * + * def heurfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of primal heuristic''' + * pass + */ + __pyx_codeobj__363 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_heuristic_pxi, __pyx_n_s_heurfree, 7, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__363)) __PYX_ERR(12, 7, __pyx_L1_error) + + /* "src/pyscipopt/heuristic.pxi":11 + * pass + * + * def heurinit(self): # <<<<<<<<<<<<<< + * '''initializes primal heuristic''' + * pass + */ + __pyx_codeobj__364 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_heuristic_pxi, __pyx_n_s_heurinit, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__364)) __PYX_ERR(12, 11, __pyx_L1_error) + + /* "src/pyscipopt/heuristic.pxi":15 + * pass + * + * def heurexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of primal heuristic''' + * pass + */ + __pyx_codeobj__365 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_heuristic_pxi, __pyx_n_s_heurexit, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__365)) __PYX_ERR(12, 15, __pyx_L1_error) + + /* "src/pyscipopt/heuristic.pxi":19 + * pass + * + * def heurinitsol(self): # <<<<<<<<<<<<<< + * '''informs primal heuristic that the branch and bound process is being started''' + * pass + */ + __pyx_codeobj__366 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_heuristic_pxi, __pyx_n_s_heurinitsol, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__366)) __PYX_ERR(12, 19, __pyx_L1_error) + + /* "src/pyscipopt/heuristic.pxi":23 + * pass + * + * def heurexitsol(self): # <<<<<<<<<<<<<< + * '''informs primal heuristic that the branch and bound process data is being freed''' + * pass + */ + __pyx_codeobj__367 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_heuristic_pxi, __pyx_n_s_heurexitsol, 23, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__367)) __PYX_ERR(12, 23, __pyx_L1_error) + + /* "src/pyscipopt/heuristic.pxi":27 + * pass + * + * def heurexec(self, heurtiming, nodeinfeasible): # <<<<<<<<<<<<<< + * '''should the heuristic the executed at the given depth, frequency, timing,...''' + * print("python error in heurexec: this method needs to be implemented") + */ + __pyx_tuple__368 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_heurtiming, __pyx_n_s_nodeinfeasible); if (unlikely(!__pyx_tuple__368)) __PYX_ERR(12, 27, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__368); + __Pyx_GIVEREF(__pyx_tuple__368); + __pyx_codeobj__369 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__368, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_heuristic_pxi, __pyx_n_s_heurexec, 27, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__369)) __PYX_ERR(12, 27, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__370 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__370)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Heur, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Heur__set_state(self, __pyx_state) + */ + __pyx_codeobj__371 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__371)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/presol.pxi":6 + * cdef public Model model + * + * def presolfree(self): # <<<<<<<<<<<<<< + * '''frees memory of presolver''' + * pass + */ + __pyx_codeobj__372 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_presol_pxi, __pyx_n_s_presolfree, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__372)) __PYX_ERR(13, 6, __pyx_L1_error) + + /* "src/pyscipopt/presol.pxi":10 + * pass + * + * def presolinit(self): # <<<<<<<<<<<<<< + * '''initializes presolver''' + * pass + */ + __pyx_codeobj__373 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_presol_pxi, __pyx_n_s_presolinit, 10, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__373)) __PYX_ERR(13, 10, __pyx_L1_error) + + /* "src/pyscipopt/presol.pxi":14 + * pass + * + * def presolexit(self): # <<<<<<<<<<<<<< + * '''deinitializes presolver''' + * pass + */ + __pyx_codeobj__374 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_presol_pxi, __pyx_n_s_presolexit, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__374)) __PYX_ERR(13, 14, __pyx_L1_error) + + /* "src/pyscipopt/presol.pxi":18 + * pass + * + * def presolinitpre(self): # <<<<<<<<<<<<<< + * '''informs presolver that the presolving process is being started''' + * pass + */ + __pyx_codeobj__375 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_presol_pxi, __pyx_n_s_presolinitpre, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__375)) __PYX_ERR(13, 18, __pyx_L1_error) + + /* "src/pyscipopt/presol.pxi":22 + * pass + * + * def presolexitpre(self): # <<<<<<<<<<<<<< + * '''informs presolver that the presolving process is finished''' + * pass + */ + __pyx_codeobj__376 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_presol_pxi, __pyx_n_s_presolexitpre, 22, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__376)) __PYX_ERR(13, 22, __pyx_L1_error) + + /* "src/pyscipopt/presol.pxi":26 + * pass + * + * def presolexec(self, nrounds, presoltiming): # <<<<<<<<<<<<<< + * '''executes presolver''' + * print("python error in presolexec: this method needs to be implemented") + */ + __pyx_tuple__377 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_nrounds, __pyx_n_s_presoltiming); if (unlikely(!__pyx_tuple__377)) __PYX_ERR(13, 26, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__377); + __Pyx_GIVEREF(__pyx_tuple__377); + __pyx_codeobj__378 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__377, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_presol_pxi, __pyx_n_s_presolexec, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__378)) __PYX_ERR(13, 26, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__379 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__379)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Presol, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Presol__set_state(self, __pyx_state) + */ + __pyx_codeobj__380 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__380)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":6 + * cdef public Model model + * + * def pricerfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of variable pricer ''' + * pass + */ + __pyx_codeobj__381 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_pricer_pxi, __pyx_n_s_pricerfree, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__381)) __PYX_ERR(14, 6, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":10 + * pass + * + * def pricerinit(self): # <<<<<<<<<<<<<< + * '''initializes variable pricer''' + * pass + */ + __pyx_codeobj__382 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_pricer_pxi, __pyx_n_s_pricerinit, 10, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__382)) __PYX_ERR(14, 10, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":14 + * pass + * + * def pricerexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of variable pricer''' + * pass + */ + __pyx_codeobj__383 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_pricer_pxi, __pyx_n_s_pricerexit, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__383)) __PYX_ERR(14, 14, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":18 + * pass + * + * def pricerinitsol(self): # <<<<<<<<<<<<<< + * '''informs variable pricer that the branch and bound process is being started ''' + * pass + */ + __pyx_codeobj__384 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_pricer_pxi, __pyx_n_s_pricerinitsol, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__384)) __PYX_ERR(14, 18, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":22 + * pass + * + * def pricerexitsol(self): # <<<<<<<<<<<<<< + * '''informs variable pricer that the branch and bound process data is being freed''' + * pass + */ + __pyx_codeobj__385 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_pricer_pxi, __pyx_n_s_pricerexitsol, 22, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__385)) __PYX_ERR(14, 22, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":26 + * pass + * + * def pricerredcost(self): # <<<<<<<<<<<<<< + * '''calls reduced cost pricing method of variable pricer''' + * raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") + */ + __pyx_codeobj__386 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_pricer_pxi, __pyx_n_s_pricerredcost, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__386)) __PYX_ERR(14, 26, __pyx_L1_error) + + /* "src/pyscipopt/pricer.pxi":30 + * raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class") + * + * def pricerfarkas(self): # <<<<<<<<<<<<<< + * '''calls Farkas pricing method of variable pricer''' + * raise NotImplementedError("pricerfarkas() is a fundamental callback and should be implemented in the derived class") + */ + __pyx_codeobj__387 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_pricer_pxi, __pyx_n_s_pricerfarkas, 30, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__387)) __PYX_ERR(14, 30, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__388 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__388)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Pricer, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Pricer__set_state(self, __pyx_state) + */ + __pyx_codeobj__389 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__389)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":6 + * cdef public Model model + * + * def propfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of propagator''' + * pass + */ + __pyx_codeobj__390 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propfree, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__390)) __PYX_ERR(15, 6, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":10 + * pass + * + * def propinit(self): # <<<<<<<<<<<<<< + * '''initializes propagator''' + * pass + */ + __pyx_codeobj__391 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propinit, 10, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__391)) __PYX_ERR(15, 10, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":14 + * pass + * + * def propexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of propagator''' + * pass + */ + __pyx_codeobj__392 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propexit, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__392)) __PYX_ERR(15, 14, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":18 + * pass + * + * def propinitsol(self): # <<<<<<<<<<<<<< + * '''informs propagator that the prop and bound process is being started''' + * pass + */ + __pyx_codeobj__393 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propinitsol, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__393)) __PYX_ERR(15, 18, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":22 + * pass + * + * def propexitsol(self, restart): # <<<<<<<<<<<<<< + * '''informs propagator that the prop and bound process data is being freed''' + * pass + */ + __pyx_tuple__394 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_restart); if (unlikely(!__pyx_tuple__394)) __PYX_ERR(15, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__394); + __Pyx_GIVEREF(__pyx_tuple__394); + __pyx_codeobj__395 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__394, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propexitsol, 22, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__395)) __PYX_ERR(15, 22, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":26 + * pass + * + * def propinitpre(self): # <<<<<<<<<<<<<< + * '''informs propagator that the presolving process is being started''' + * pass + */ + __pyx_codeobj__396 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propinitpre, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__396)) __PYX_ERR(15, 26, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":30 + * pass + * + * def propexitpre(self): # <<<<<<<<<<<<<< + * '''informs propagator that the presolving process is finished''' + * pass + */ + __pyx_codeobj__397 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propexitpre, 30, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__397)) __PYX_ERR(15, 30, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":34 + * pass + * + * def proppresol(self, nrounds, presoltiming, result_dict): # <<<<<<<<<<<<<< + * '''executes presolving method of propagator''' + * pass + */ + __pyx_tuple__398 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_nrounds, __pyx_n_s_presoltiming, __pyx_n_s_result_dict); if (unlikely(!__pyx_tuple__398)) __PYX_ERR(15, 34, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__398); + __Pyx_GIVEREF(__pyx_tuple__398); + __pyx_codeobj__399 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__398, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_proppresol, 34, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__399)) __PYX_ERR(15, 34, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":38 + * pass + * + * def propexec(self, proptiming): # <<<<<<<<<<<<<< + * '''calls execution method of propagator''' + * print("python error in propexec: this method needs to be implemented") + */ + __pyx_tuple__400 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_proptiming); if (unlikely(!__pyx_tuple__400)) __PYX_ERR(15, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__400); + __Pyx_GIVEREF(__pyx_tuple__400); + __pyx_codeobj__401 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__400, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propexec, 38, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__401)) __PYX_ERR(15, 38, __pyx_L1_error) + + /* "src/pyscipopt/propagator.pxi":43 + * return {} + * + * def propresprop(self, confvar, inferinfo, bdtype, relaxedbd): # <<<<<<<<<<<<<< + * '''resolves the given conflicting bound, that was reduced by the given propagator''' + * print("python error in propresprop: this method needs to be implemented") + */ + __pyx_tuple__402 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_confvar, __pyx_n_s_inferinfo, __pyx_n_s_bdtype, __pyx_n_s_relaxedbd); if (unlikely(!__pyx_tuple__402)) __PYX_ERR(15, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__402); + __Pyx_GIVEREF(__pyx_tuple__402); + __pyx_codeobj__403 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__402, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_propagator_pxi, __pyx_n_s_propresprop, 43, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__403)) __PYX_ERR(15, 43, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__404 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__404)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Prop, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Prop__set_state(self, __pyx_state) + */ + __pyx_codeobj__405 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__405)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/sepa.pxi":7 + * cdef public str name + * + * def sepafree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of separator''' + * pass + */ + __pyx_codeobj__406 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_sepa_pxi, __pyx_n_s_sepafree, 7, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__406)) __PYX_ERR(16, 7, __pyx_L1_error) + + /* "src/pyscipopt/sepa.pxi":11 + * pass + * + * def sepainit(self): # <<<<<<<<<<<<<< + * '''initializes separator''' + * pass + */ + __pyx_codeobj__407 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_sepa_pxi, __pyx_n_s_sepainit, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__407)) __PYX_ERR(16, 11, __pyx_L1_error) + + /* "src/pyscipopt/sepa.pxi":15 + * pass + * + * def sepaexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of separator''' + * pass + */ + __pyx_codeobj__408 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_sepa_pxi, __pyx_n_s_sepaexit, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__408)) __PYX_ERR(16, 15, __pyx_L1_error) + + /* "src/pyscipopt/sepa.pxi":19 + * pass + * + * def sepainitsol(self): # <<<<<<<<<<<<<< + * '''informs separator that the branch and bound process is being started''' + * pass + */ + __pyx_codeobj__409 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_sepa_pxi, __pyx_n_s_sepainitsol, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__409)) __PYX_ERR(16, 19, __pyx_L1_error) + + /* "src/pyscipopt/sepa.pxi":23 + * pass + * + * def sepaexitsol(self): # <<<<<<<<<<<<<< + * '''informs separator that the branch and bound process data is being freed''' + * pass + */ + __pyx_codeobj__410 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_sepa_pxi, __pyx_n_s_sepaexitsol, 23, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__410)) __PYX_ERR(16, 23, __pyx_L1_error) + + /* "src/pyscipopt/sepa.pxi":27 + * pass + * + * def sepaexeclp(self): # <<<<<<<<<<<<<< + * '''calls LP separation method of separator''' + * return {} + */ + __pyx_codeobj__411 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_sepa_pxi, __pyx_n_s_sepaexeclp, 27, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__411)) __PYX_ERR(16, 27, __pyx_L1_error) + + /* "src/pyscipopt/sepa.pxi":31 + * return {} + * + * def sepaexecsol(self, solution): # <<<<<<<<<<<<<< + * '''calls primal solution separation method of separator''' + * return {} + */ + __pyx_tuple__412 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_solution); if (unlikely(!__pyx_tuple__412)) __PYX_ERR(16, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__412); + __Pyx_GIVEREF(__pyx_tuple__412); + __pyx_codeobj__413 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__412, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_sepa_pxi, __pyx_n_s_sepaexecsol, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__413)) __PYX_ERR(16, 31, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__414 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__414)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Sepa, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Sepa__set_state(self, __pyx_state) + */ + __pyx_codeobj__415 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__415)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/reader.pxi":7 + * cdef public str name + * + * def readerfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of reader''' + * pass + */ + __pyx_codeobj__416 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_reader_pxi, __pyx_n_s_readerfree, 7, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__416)) __PYX_ERR(17, 7, __pyx_L1_error) + + /* "src/pyscipopt/reader.pxi":11 + * pass + * + * def readerread(self, filename): # <<<<<<<<<<<<<< + * '''calls read method of reader''' + * return {} + */ + __pyx_codeobj__417 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__194, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_reader_pxi, __pyx_n_s_readerread, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__417)) __PYX_ERR(17, 11, __pyx_L1_error) + + /* "src/pyscipopt/reader.pxi":15 + * return {} + * + * def readerwrite(self, file, name, transformed, objsense, objscale, objoffset, binvars, intvars, # <<<<<<<<<<<<<< + * implvars, contvars, fixedvars, startnvars, conss, maxnconss, startnconss, genericnames): + * '''calls write method of reader''' + */ + __pyx_tuple__418 = PyTuple_Pack(17, __pyx_n_s_self, __pyx_n_s_file, __pyx_n_s_name, __pyx_n_s_transformed, __pyx_n_s_objsense, __pyx_n_s_objscale, __pyx_n_s_objoffset, __pyx_n_s_binvars, __pyx_n_s_intvars, __pyx_n_s_implvars, __pyx_n_s_contvars, __pyx_n_s_fixedvars, __pyx_n_s_startnvars, __pyx_n_s_conss, __pyx_n_s_maxnconss, __pyx_n_s_startnconss, __pyx_n_s_genericnames); if (unlikely(!__pyx_tuple__418)) __PYX_ERR(17, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__418); + __Pyx_GIVEREF(__pyx_tuple__418); + __pyx_codeobj__419 = (PyObject*)__Pyx_PyCode_New(17, 0, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__418, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_reader_pxi, __pyx_n_s_readerwrite, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__419)) __PYX_ERR(17, 15, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__420 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__420)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Reader, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Reader__set_state(self, __pyx_state) + */ + __pyx_codeobj__421 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__421)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/relax.pxi":7 + * cdef public str name + * + * def relaxfree(self): # <<<<<<<<<<<<<< + * '''calls destructor and frees memory of relaxation handler''' + * pass + */ + __pyx_codeobj__422 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_relax_pxi, __pyx_n_s_relaxfree, 7, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__422)) __PYX_ERR(18, 7, __pyx_L1_error) + + /* "src/pyscipopt/relax.pxi":11 + * pass + * + * def relaxinit(self): # <<<<<<<<<<<<<< + * '''initializes relaxation handler''' + * pass + */ + __pyx_codeobj__423 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_relax_pxi, __pyx_n_s_relaxinit, 11, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__423)) __PYX_ERR(18, 11, __pyx_L1_error) + + /* "src/pyscipopt/relax.pxi":15 + * pass + * + * def relaxexit(self): # <<<<<<<<<<<<<< + * '''calls exit method of relaxation handler''' + * pass + */ + __pyx_codeobj__424 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_relax_pxi, __pyx_n_s_relaxexit, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__424)) __PYX_ERR(18, 15, __pyx_L1_error) + + /* "src/pyscipopt/relax.pxi":19 + * pass + * + * def relaxinitsol(self): # <<<<<<<<<<<<<< + * '''informs relaxaton handler that the branch and bound process is being started''' + * pass + */ + __pyx_codeobj__425 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_relax_pxi, __pyx_n_s_relaxinitsol, 19, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__425)) __PYX_ERR(18, 19, __pyx_L1_error) + + /* "src/pyscipopt/relax.pxi":23 + * pass + * + * def relaxexitsol(self): # <<<<<<<<<<<<<< + * '''informs relaxation handler that the branch and bound process data is being freed''' + * pass + */ + __pyx_codeobj__426 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_relax_pxi, __pyx_n_s_relaxexitsol, 23, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__426)) __PYX_ERR(18, 23, __pyx_L1_error) + + /* "src/pyscipopt/relax.pxi":27 + * pass + * + * def relaxexec(self): # <<<<<<<<<<<<<< + * '''callls execution method of relaxation handler''' + * print("python error in relaxexec: this method needs to be implemented") + */ + __pyx_codeobj__427 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_relax_pxi, __pyx_n_s_relaxexec, 27, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__427)) __PYX_ERR(18, 27, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__428 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__428)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Relax, (type(self), 0x48f811e, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Relax__set_state(self, __pyx_state) + */ + __pyx_codeobj__429 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__429)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/nodesel.pxi":6 + * cdef public Model model + * + * def nodefree(self): # <<<<<<<<<<<<<< + * '''frees memory of node selector''' + * pass + */ + __pyx_codeobj__430 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_nodesel_pxi, __pyx_n_s_nodefree, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__430)) __PYX_ERR(19, 6, __pyx_L1_error) + + /* "src/pyscipopt/nodesel.pxi":10 + * pass + * + * def nodeinit(self): # <<<<<<<<<<<<<< + * ''' executed after the problem is transformed. use this call to initialize node selector data.''' + * pass + */ + __pyx_codeobj__431 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_nodesel_pxi, __pyx_n_s_nodeinit, 10, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__431)) __PYX_ERR(19, 10, __pyx_L1_error) + + /* "src/pyscipopt/nodesel.pxi":14 + * pass + * + * def nodeexit(self): # <<<<<<<<<<<<<< + * '''executed before the transformed problem is freed''' + * pass + */ + __pyx_codeobj__432 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_nodesel_pxi, __pyx_n_s_nodeexit, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__432)) __PYX_ERR(19, 14, __pyx_L1_error) + + /* "src/pyscipopt/nodesel.pxi":18 + * pass + * + * def nodeinitsol(self): # <<<<<<<<<<<<<< + * '''executed when the presolving is finished and the branch-and-bound process is about to begin''' + * pass + */ + __pyx_codeobj__433 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_nodesel_pxi, __pyx_n_s_nodeinitsol, 18, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__433)) __PYX_ERR(19, 18, __pyx_L1_error) + + /* "src/pyscipopt/nodesel.pxi":22 + * pass + * + * def nodeexitsol(self): # <<<<<<<<<<<<<< + * '''executed before the branch-and-bound process is freed''' + * pass + */ + __pyx_codeobj__434 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_nodesel_pxi, __pyx_n_s_nodeexitsol, 22, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__434)) __PYX_ERR(19, 22, __pyx_L1_error) + + /* "src/pyscipopt/nodesel.pxi":26 + * pass + * + * def nodeselect(self): # <<<<<<<<<<<<<< + * '''first method called in each iteration in the main solving loop. ''' + * # this method needs to be implemented by the user + */ + __pyx_codeobj__435 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_nodesel_pxi, __pyx_n_s_nodeselect, 26, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__435)) __PYX_ERR(19, 26, __pyx_L1_error) + + /* "src/pyscipopt/nodesel.pxi":31 + * return {} + * + * def nodecomp(self, node1, node2): # <<<<<<<<<<<<<< + * ''' + * compare two leaves of the current branching tree + */ + __pyx_tuple__436 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_node1, __pyx_n_s_node2); if (unlikely(!__pyx_tuple__436)) __PYX_ERR(19, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__436); + __Pyx_GIVEREF(__pyx_tuple__436); + __pyx_codeobj__437 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__436, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_nodesel_pxi, __pyx_n_s_nodecomp, 31, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__437)) __PYX_ERR(19, 31, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__438 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__438)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Nodesel__set_state(self, __pyx_state) + */ + __pyx_codeobj__439 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__439)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":46 + * # todo: check whether this is currently done like this + * + * if sys.version_info >= (3, 0): # <<<<<<<<<<<<<< + * str_conversion = lambda x:bytes(x,'utf-8') + * else: + */ + __pyx_tuple__440 = PyTuple_Pack(2, __pyx_int_3, __pyx_int_0); if (unlikely(!__pyx_tuple__440)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__440); + __Pyx_GIVEREF(__pyx_tuple__440); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__443 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__443)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_RESULT__set_state(self, __pyx_state) + */ + __pyx_codeobj__444 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__444)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__445 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__445)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(self, __pyx_state) + */ + __pyx_codeobj__446 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__446)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__447 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__447)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(self, __pyx_state) + */ + __pyx_codeobj__448 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__448)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__449 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__449)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STATUS__set_state(self, __pyx_state) + */ + __pyx_codeobj__450 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__450)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__451 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__451)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_STAGE__set_state(self, __pyx_state) + */ + __pyx_codeobj__452 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__452)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__453 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__453)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_NODETYPE__set_state(self, __pyx_state) + */ + __pyx_codeobj__454 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__454)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__455 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__455)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(self, __pyx_state) + */ + __pyx_codeobj__456 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__456)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__457 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__457)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(self, __pyx_state) + */ + __pyx_codeobj__458 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__458)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__459 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__459)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(self, __pyx_state) + */ + __pyx_codeobj__460 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__460)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__461 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__461)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(self, __pyx_state) + */ + __pyx_codeobj__462 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__462)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__463 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__463)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(self, __pyx_state) + */ + __pyx_codeobj__464 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__464)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__465 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__465)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(self, __pyx_state) + */ + __pyx_codeobj__466 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__466)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__467 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__467)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(self, __pyx_state) + */ + __pyx_codeobj__468 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__468)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_codeobj__469 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__469)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(self, __pyx_state) + */ + __pyx_codeobj__470 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__470)) __PYX_ERR(6, 16, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":260 + * REOPT = SCIP_ROWORIGINTYPE_REOPT + * + * def PY_SCIP_CALL(SCIP_RETCODE rc): # <<<<<<<<<<<<<< + * if rc == SCIP_OKAY: + * pass + */ + __pyx_tuple__471 = PyTuple_Pack(1, __pyx_n_s_rc); if (unlikely(!__pyx_tuple__471)) __PYX_ERR(0, 260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__471); + __Pyx_GIVEREF(__pyx_tuple__471); + __pyx_codeobj__472 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__471, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_PY_SCIP_CALL, 260, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__472)) __PYX_ERR(0, 260, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":312 + * return event + * + * def getType(self): # <<<<<<<<<<<<<< + * """gets type of event""" + * return SCIPeventGetType(self.event) + */ + __pyx_codeobj__473 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getType, 312, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__473)) __PYX_ERR(0, 312, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":316 + * return SCIPeventGetType(self.event) + * + * def getName(self): # <<<<<<<<<<<<<< + * """gets name of event""" + * if not EventNames: + */ + __pyx_codeobj__474 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getName, 316, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__474)) __PYX_ERR(0, 316, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":322 + * return EventNames[self.getType()] + * + * def _getEventNames(self): # <<<<<<<<<<<<<< + * """gets event names""" + * for name in dir(PY_SCIP_EVENTTYPE): + */ + __pyx_tuple__475 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_attr); if (unlikely(!__pyx_tuple__475)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__475); + __Pyx_GIVEREF(__pyx_tuple__475); + __pyx_codeobj__476 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__475, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getEventNames, 322, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__476)) __PYX_ERR(0, 322, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":335 + * return self.getName() + * + * def getNewBound(self): # <<<<<<<<<<<<<< + * """gets new bound for a bound change event""" + * return SCIPeventGetNewbound(self.event) + */ + __pyx_codeobj__477 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNewBound, 335, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__477)) __PYX_ERR(0, 335, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":339 + * return SCIPeventGetNewbound(self.event) + * + * def getOldBound(self): # <<<<<<<<<<<<<< + * """gets old bound for a bound change event""" + * return SCIPeventGetOldbound(self.event) + */ + __pyx_codeobj__478 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getOldBound, 339, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__478)) __PYX_ERR(0, 339, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":343 + * return SCIPeventGetOldbound(self.event) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)""" + * cdef SCIP_VAR* var = SCIPeventGetVar(self.event) + */ + __pyx_tuple__479 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_var); if (unlikely(!__pyx_tuple__479)) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__479); + __Pyx_GIVEREF(__pyx_tuple__479); + __pyx_codeobj__480 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__479, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVar, 343, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__480)) __PYX_ERR(0, 343, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":348 + * return Variable.create(var) + * + * def getNode(self): # <<<<<<<<<<<<<< + * """gets node for a node or LP event""" + * cdef SCIP_NODE* node = SCIPeventGetNode(self.event) + */ + __pyx_tuple__481 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_node); if (unlikely(!__pyx_tuple__481)) __PYX_ERR(0, 348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__481); + __Pyx_GIVEREF(__pyx_tuple__481); + __pyx_codeobj__482 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__481, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNode, 348, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__482)) __PYX_ERR(0, 348, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":353 + * return Node.create(node) + * + * def getRow(self): # <<<<<<<<<<<<<< + * """gets row for a row event""" + * cdef SCIP_ROW* row = SCIPeventGetRow(self.event) + */ + __pyx_tuple__483 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_row); if (unlikely(!__pyx_tuple__483)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__483); + __Pyx_GIVEREF(__pyx_tuple__483); + __pyx_codeobj__484 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRow, 353, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__484)) __PYX_ERR(0, 353, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__485 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__485)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.event cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__486 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__486)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":376 + * return col + * + * def getLPPos(self): # <<<<<<<<<<<<<< + * """gets position of column in current LP, or -1 if it is not in LP""" + * return SCIPcolGetLPPos(self.scip_col) + */ + __pyx_codeobj__487 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPPos, 376, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__487)) __PYX_ERR(0, 376, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":380 + * return SCIPcolGetLPPos(self.scip_col) + * + * def getBasisStatus(self): # <<<<<<<<<<<<<< + * """gets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col) + */ + __pyx_tuple__488 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_stat); if (unlikely(!__pyx_tuple__488)) __PYX_ERR(0, 380, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__488); + __Pyx_GIVEREF(__pyx_tuple__488); + __pyx_codeobj__489 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__488, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBasisStatus, 380, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__489)) __PYX_ERR(0, 380, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":394 + * raise Exception('SCIP returned unknown base status!') + * + * def isIntegral(self): # <<<<<<<<<<<<<< + * """returns whether the associated variable is of integral type (binary, integer, implicit integer)""" + * return SCIPcolIsIntegral(self.scip_col) + */ + __pyx_codeobj__490 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isIntegral, 394, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__490)) __PYX_ERR(0, 394, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":398 + * return SCIPcolIsIntegral(self.scip_col) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """gets variable this column represents""" + * cdef SCIP_VAR* var = SCIPcolGetVar(self.scip_col) + */ + __pyx_codeobj__491 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__479, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVar, 398, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__491)) __PYX_ERR(0, 398, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":403 + * return Variable.create(var) + * + * def getPrimsol(self): # <<<<<<<<<<<<<< + * """gets the primal LP solution of a column""" + * return SCIPcolGetPrimsol(self.scip_col) + */ + __pyx_codeobj__492 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getPrimsol, 403, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__492)) __PYX_ERR(0, 403, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":407 + * return SCIPcolGetPrimsol(self.scip_col) + * + * def getLb(self): # <<<<<<<<<<<<<< + * """gets lower bound of column""" + * return SCIPcolGetLb(self.scip_col) + */ + __pyx_codeobj__493 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLb, 407, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__493)) __PYX_ERR(0, 407, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":411 + * return SCIPcolGetLb(self.scip_col) + * + * def getUb(self): # <<<<<<<<<<<<<< + * """gets upper bound of column""" + * return SCIPcolGetUb(self.scip_col) + */ + __pyx_codeobj__494 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getUb, 411, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__494)) __PYX_ERR(0, 411, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":415 + * return SCIPcolGetUb(self.scip_col) + * + * def getObjCoeff(self): # <<<<<<<<<<<<<< + * """gets objective value coefficient of a column""" + * return SCIPcolGetObj(self.scip_col) + */ + __pyx_codeobj__495 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getObjCoeff, 415, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__495)) __PYX_ERR(0, 415, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__496 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__496)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_col cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__497 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__497)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":442 + * return cname.decode('utf-8') + * + * def getLhs(self): # <<<<<<<<<<<<<< + * """returns the left hand side of row""" + * return SCIProwGetLhs(self.scip_row) + */ + __pyx_codeobj__498 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLhs, 442, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__498)) __PYX_ERR(0, 442, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":446 + * return SCIProwGetLhs(self.scip_row) + * + * def getRhs(self): # <<<<<<<<<<<<<< + * """returns the right hand side of row""" + * return SCIProwGetRhs(self.scip_row) + */ + __pyx_codeobj__499 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRhs, 446, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__499)) __PYX_ERR(0, 446, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":450 + * return SCIProwGetRhs(self.scip_row) + * + * def getConstant(self): # <<<<<<<<<<<<<< + * """gets constant shift of row""" + * return SCIProwGetConstant(self.scip_row) + */ + __pyx_codeobj__500 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getConstant, 450, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__500)) __PYX_ERR(0, 450, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":454 + * return SCIProwGetConstant(self.scip_row) + * + * def getLPPos(self): # <<<<<<<<<<<<<< + * """gets position of row in current LP, or -1 if it is not in LP""" + * return SCIProwGetLPPos(self.scip_row) + */ + __pyx_codeobj__501 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPPos, 454, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__501)) __PYX_ERR(0, 454, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":458 + * return SCIProwGetLPPos(self.scip_row) + * + * def getBasisStatus(self): # <<<<<<<<<<<<<< + * """gets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP""" + * cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row) + */ + __pyx_codeobj__502 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__488, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBasisStatus, 458, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__502)) __PYX_ERR(0, 458, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":473 + * raise Exception('SCIP returned unknown base status!') + * + * def isIntegral(self): # <<<<<<<<<<<<<< + * """returns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution """ + * return SCIProwIsIntegral(self.scip_row) + */ + __pyx_codeobj__503 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isIntegral, 473, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__503)) __PYX_ERR(0, 473, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":477 + * return SCIProwIsIntegral(self.scip_row) + * + * def isLocal(self): # <<<<<<<<<<<<<< + * """returns TRUE iff the row is only valid locally """ + * return SCIProwIsLocal(self.scip_row) + */ + __pyx_codeobj__504 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isLocal, 477, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__504)) __PYX_ERR(0, 477, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":481 + * return SCIProwIsLocal(self.scip_row) + * + * def isModifiable(self): # <<<<<<<<<<<<<< + * """returns TRUE iff row is modifiable during node processing (subject to column generation) """ + * return SCIProwIsModifiable(self.scip_row) + */ + __pyx_codeobj__505 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isModifiable, 481, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__505)) __PYX_ERR(0, 481, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":485 + * return SCIProwIsModifiable(self.scip_row) + * + * def isRemovable(self): # <<<<<<<<<<<<<< + * """returns TRUE iff row is removable from the LP (due to aging or cleanup)""" + * return SCIProwIsRemovable(self.scip_row) + */ + __pyx_codeobj__506 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isRemovable, 485, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__506)) __PYX_ERR(0, 485, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":489 + * return SCIProwIsRemovable(self.scip_row) + * + * def isInGlobalCutpool(self): # <<<<<<<<<<<<<< + * """return TRUE iff row is a member of the global cut pool""" + * return SCIProwIsInGlobalCutpool(self.scip_row) + */ + __pyx_codeobj__507 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isInGlobalCutpool, 489, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__507)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":493 + * return SCIProwIsInGlobalCutpool(self.scip_row) + * + * def getOrigintype(self): # <<<<<<<<<<<<<< + * """returns type of origin that created the row""" + * return SCIProwGetOrigintype(self.scip_row) + */ + __pyx_codeobj__508 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getOrigintype, 493, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__508)) __PYX_ERR(0, 493, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":497 + * return SCIProwGetOrigintype(self.scip_row) + * + * def getConsOriginConshdlrtype(self): # <<<<<<<<<<<<<< + * """returns type of constraint handler that created the row""" + * cdef SCIP_CONS* scip_con = SCIProwGetOriginCons(self.scip_row) + */ + __pyx_tuple__509 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_scip_con); if (unlikely(!__pyx_tuple__509)) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__509); + __Pyx_GIVEREF(__pyx_tuple__509); + __pyx_codeobj__510 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__509, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getConsOriginConshdlrtype, 497, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__510)) __PYX_ERR(0, 497, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":502 + * return bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(scip_con))).decode('UTF-8') + * + * def getNNonz(self): # <<<<<<<<<<<<<< + * """get number of nonzero entries in row vector""" + * return SCIProwGetNNonz(self.scip_row) + */ + __pyx_codeobj__511 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNNonz, 502, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__511)) __PYX_ERR(0, 502, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":506 + * return SCIProwGetNNonz(self.scip_row) + * + * def getNLPNonz(self): # <<<<<<<<<<<<<< + * """get number of nonzero entries in row vector that correspond to columns currently in the SCIP LP""" + * return SCIProwGetNLPNonz(self.scip_row) + */ + __pyx_codeobj__512 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNLPNonz, 506, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__512)) __PYX_ERR(0, 506, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":510 + * return SCIProwGetNLPNonz(self.scip_row) + * + * def getCols(self): # <<<<<<<<<<<<<< + * """gets list with columns of nonzero entries""" + * cdef SCIP_COL** cols = SCIProwGetCols(self.scip_row) + */ + __pyx_tuple__513 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cols, __pyx_n_s_i); if (unlikely(!__pyx_tuple__513)) __PYX_ERR(0, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__513); + __Pyx_GIVEREF(__pyx_tuple__513); + __pyx_codeobj__514 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__513, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getCols, 510, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__514)) __PYX_ERR(0, 510, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":515 + * return [Column.create(cols[i]) for i in range(self.getNNonz())] + * + * def getVals(self): # <<<<<<<<<<<<<< + * """gets list with coefficients of nonzero entries""" + * cdef SCIP_Real* vals = SCIProwGetVals(self.scip_row) + */ + __pyx_tuple__515 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_vals, __pyx_n_s_i); if (unlikely(!__pyx_tuple__515)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__515); + __Pyx_GIVEREF(__pyx_tuple__515); + __pyx_codeobj__516 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__515, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVals, 515, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__516)) __PYX_ERR(0, 515, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":520 + * return [vals[i] for i in range(self.getNNonz())] + * + * def getNorm(self): # <<<<<<<<<<<<<< + * """gets Euclidean norm of row vector """ + * return SCIProwGetNorm(self.scip_row) + */ + __pyx_codeobj__517 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNorm, 520, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__517)) __PYX_ERR(0, 520, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__518 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__518)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_row cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__519 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__519)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":547 + * return cname.decode('utf-8') + * + * def getConstant(self): # <<<<<<<<<<<<<< + * """returns the constant of a nonlinear row""" + * return SCIPnlrowGetConstant(self.scip_nlrow) + */ + __pyx_codeobj__520 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getConstant, 547, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__520)) __PYX_ERR(0, 547, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":551 + * return SCIPnlrowGetConstant(self.scip_nlrow) + * + * def getLinearTerms(self): # <<<<<<<<<<<<<< + * """returns a list of tuples (var, coef) representing the linear part of a nonlinear row""" + * cdef SCIP_VAR** linvars = SCIPnlrowGetLinearVars(self.scip_nlrow) + */ + __pyx_tuple__521 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_linvars, __pyx_n_s_lincoefs, __pyx_n_s_nlinvars, __pyx_n_s_i); if (unlikely(!__pyx_tuple__521)) __PYX_ERR(0, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__521); + __Pyx_GIVEREF(__pyx_tuple__521); + __pyx_codeobj__522 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__521, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLinearTerms, 551, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__522)) __PYX_ERR(0, 551, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":558 + * return [(Variable.create(linvars[i]), lincoefs[i]) for i in range(nlinvars)] + * + * def getLhs(self): # <<<<<<<<<<<<<< + * """returns the left hand side of a nonlinear row""" + * return SCIPnlrowGetLhs(self.scip_nlrow) + */ + __pyx_codeobj__523 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLhs, 558, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__523)) __PYX_ERR(0, 558, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":562 + * return SCIPnlrowGetLhs(self.scip_nlrow) + * + * def getRhs(self): # <<<<<<<<<<<<<< + * """returns the right hand side of a nonlinear row""" + * return SCIPnlrowGetRhs(self.scip_nlrow) + */ + __pyx_codeobj__524 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRhs, 562, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__524)) __PYX_ERR(0, 562, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":566 + * return SCIPnlrowGetRhs(self.scip_nlrow) + * + * def getDualsol(self): # <<<<<<<<<<<<<< + * """gets the dual NLP solution of a nonlinear row""" + * return SCIPnlrowGetDualsol(self.scip_nlrow) + */ + __pyx_codeobj__525 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDualsol, 566, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__525)) __PYX_ERR(0, 566, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__526 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__526)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__527 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__527)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":602 + * return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0) + * + * def _evaluate(self, term): # <<<<<<<<<<<<<< + * self._checkStage("SCIPgetSolVal") + * result = 1 + */ + __pyx_tuple__528 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_term, __pyx_n_s_result, __pyx_n_s_var); if (unlikely(!__pyx_tuple__528)) __PYX_ERR(0, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__528); + __Pyx_GIVEREF(__pyx_tuple__528); + __pyx_codeobj__529 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__528, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_evaluate, 602, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__529)) __PYX_ERR(0, 602, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":627 + * return str(vals) + * + * def _checkStage(self, method): # <<<<<<<<<<<<<< + * if method in ["SCIPgetSolVal", "getSolObjVal"]: + * if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING: + */ + __pyx_tuple__530 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_method); if (unlikely(!__pyx_tuple__530)) __PYX_ERR(0, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__530); + __Pyx_GIVEREF(__pyx_tuple__530); + __pyx_codeobj__531 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__530, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_checkStage, 627, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__531)) __PYX_ERR(0, 627, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__532 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__532)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__533 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__533)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":644 + * return boundchg + * + * def getNewBound(self): # <<<<<<<<<<<<<< + * """Returns the new value of the bound in the bound change.""" + * return SCIPboundchgGetNewbound(self.scip_boundchg) + */ + __pyx_codeobj__534 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNewBound, 644, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__534)) __PYX_ERR(0, 644, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":648 + * return SCIPboundchgGetNewbound(self.scip_boundchg) + * + * def getVar(self): # <<<<<<<<<<<<<< + * """Returns the variable of the bound change.""" + * return Variable.create(SCIPboundchgGetVar(self.scip_boundchg)) + */ + __pyx_codeobj__535 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVar, 648, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__535)) __PYX_ERR(0, 648, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":652 + * return Variable.create(SCIPboundchgGetVar(self.scip_boundchg)) + * + * def getBoundchgtype(self): # <<<<<<<<<<<<<< + * """Returns the bound change type of the bound change.""" + * return SCIPboundchgGetBoundchgtype(self.scip_boundchg) + */ + __pyx_codeobj__536 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBoundchgtype, 652, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__536)) __PYX_ERR(0, 652, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":656 + * return SCIPboundchgGetBoundchgtype(self.scip_boundchg) + * + * def getBoundtype(self): # <<<<<<<<<<<<<< + * """Returns the bound type of the bound change.""" + * return SCIPboundchgGetBoundtype(self.scip_boundchg) + */ + __pyx_codeobj__537 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBoundtype, 656, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__537)) __PYX_ERR(0, 656, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":660 + * return SCIPboundchgGetBoundtype(self.scip_boundchg) + * + * def isRedundant(self): # <<<<<<<<<<<<<< + * """Returns whether the bound change is redundant due to a more global bound that is at least as strong.""" + * return SCIPboundchgIsRedundant(self.scip_boundchg) + */ + __pyx_codeobj__538 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isRedundant, 660, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__538)) __PYX_ERR(0, 660, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__539 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__539)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__540 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__540)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":680 + * return domchg + * + * def getBoundchgs(self): # <<<<<<<<<<<<<< + * """Returns the bound changes in the domain change.""" + * nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg) + */ + __pyx_tuple__541 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_nboundchgs, __pyx_n_s_i); if (unlikely(!__pyx_tuple__541)) __PYX_ERR(0, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__541); + __Pyx_GIVEREF(__pyx_tuple__541); + __pyx_codeobj__542 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__541, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBoundchgs, 680, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__542)) __PYX_ERR(0, 680, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__543 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__543)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__544 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__544)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":697 + * return node + * + * def getParent(self): # <<<<<<<<<<<<<< + * """Retrieve parent node (or None if the node has no parent node).""" + * return Node.create(SCIPnodeGetParent(self.scip_node)) + */ + __pyx_codeobj__545 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getParent, 697, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__545)) __PYX_ERR(0, 697, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":701 + * return Node.create(SCIPnodeGetParent(self.scip_node)) + * + * def getNumber(self): # <<<<<<<<<<<<<< + * """Retrieve number of node.""" + * return SCIPnodeGetNumber(self.scip_node) + */ + __pyx_codeobj__546 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNumber, 701, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__546)) __PYX_ERR(0, 701, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":705 + * return SCIPnodeGetNumber(self.scip_node) + * + * def getDepth(self): # <<<<<<<<<<<<<< + * """Retrieve depth of node.""" + * return SCIPnodeGetDepth(self.scip_node) + */ + __pyx_codeobj__547 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDepth, 705, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__547)) __PYX_ERR(0, 705, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":709 + * return SCIPnodeGetDepth(self.scip_node) + * + * def getType(self): # <<<<<<<<<<<<<< + * """Retrieve type of node.""" + * return SCIPnodeGetType(self.scip_node) + */ + __pyx_codeobj__548 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getType, 709, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__548)) __PYX_ERR(0, 709, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":713 + * return SCIPnodeGetType(self.scip_node) + * + * def getLowerbound(self): # <<<<<<<<<<<<<< + * """Retrieve lower bound of node.""" + * return SCIPnodeGetLowerbound(self.scip_node) + */ + __pyx_codeobj__549 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLowerbound, 713, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__549)) __PYX_ERR(0, 713, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":717 + * return SCIPnodeGetLowerbound(self.scip_node) + * + * def getEstimate(self): # <<<<<<<<<<<<<< + * """Retrieve the estimated value of the best feasible solution in subtree of the node""" + * return SCIPnodeGetEstimate(self.scip_node) + */ + __pyx_codeobj__550 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getEstimate, 717, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__550)) __PYX_ERR(0, 717, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":721 + * return SCIPnodeGetEstimate(self.scip_node) + * + * def getAddedConss(self): # <<<<<<<<<<<<<< + * """Retrieve all constraints added at this node.""" + * cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node) + */ + __pyx_tuple__551 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_addedconsssize, __pyx_n_s_addedconss, __pyx_n_s_nconss, __pyx_n_s_constraints, __pyx_n_s_i); if (unlikely(!__pyx_tuple__551)) __PYX_ERR(0, 721, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__551); + __Pyx_GIVEREF(__pyx_tuple__551); + __pyx_codeobj__552 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__551, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getAddedConss, 721, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__552)) __PYX_ERR(0, 721, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":734 + * return constraints + * + * def getNAddedConss(self): # <<<<<<<<<<<<<< + * """Retrieve number of added constraints at this node""" + * return SCIPnodeGetNAddedConss(self.scip_node) + */ + __pyx_codeobj__553 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNAddedConss, 734, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__553)) __PYX_ERR(0, 734, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":738 + * return SCIPnodeGetNAddedConss(self.scip_node) + * + * def isActive(self): # <<<<<<<<<<<<<< + * """Is the node in the path to the current node?""" + * return SCIPnodeIsActive(self.scip_node) + */ + __pyx_codeobj__554 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isActive, 738, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__554)) __PYX_ERR(0, 738, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":742 + * return SCIPnodeIsActive(self.scip_node) + * + * def isPropagatedAgain(self): # <<<<<<<<<<<<<< + * """Is the node marked to be propagated again?""" + * return SCIPnodeIsPropagatedAgain(self.scip_node) + */ + __pyx_codeobj__555 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isPropagatedAgain, 742, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__555)) __PYX_ERR(0, 742, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":746 + * return SCIPnodeIsPropagatedAgain(self.scip_node) + * + * def getNParentBranchings(self): # <<<<<<<<<<<<<< + * """Retrieve the number of variable branchings that were performed in the parent node to create this node.""" + * cdef SCIP_VAR* dummy_branchvars + */ + __pyx_tuple__556 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_dummy_branchvars, __pyx_n_s_dummy_branchbounds, __pyx_n_s_dummy_boundtypes, __pyx_n_s_nbranchvars); if (unlikely(!__pyx_tuple__556)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__556); + __Pyx_GIVEREF(__pyx_tuple__556); + __pyx_codeobj__557 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__556, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNParentBranchings, 746, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__557)) __PYX_ERR(0, 746, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":760 + * return nbranchvars + * + * def getParentBranchings(self): # <<<<<<<<<<<<<< + * """Retrieve the set of variable branchings that were performed in the parent node to create this node.""" + * cdef int nbranchvars = self.getNParentBranchings() + */ + __pyx_tuple__558 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_nbranchvars, __pyx_n_s_branchvars, __pyx_n_s_branchbounds, __pyx_n_s_boundtypes, __pyx_n_s_py_variables, __pyx_n_s_py_branchbounds, __pyx_n_s_py_boundtypes, __pyx_n_s_i, __pyx_n_s_i, __pyx_n_s_i); if (unlikely(!__pyx_tuple__558)) __PYX_ERR(0, 760, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__558); + __Pyx_GIVEREF(__pyx_tuple__558); + __pyx_codeobj__559 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__558, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getParentBranchings, 760, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__559)) __PYX_ERR(0, 760, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":782 + * return py_variables, py_branchbounds, py_boundtypes + * + * def getNDomchg(self): # <<<<<<<<<<<<<< + * """Retrieve the number of bound changes due to branching, constraint propagation, and propagation.""" + * cdef int nbranchings + */ + __pyx_tuple__560 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_nbranchings, __pyx_n_s_nconsprop, __pyx_n_s_nprop); if (unlikely(!__pyx_tuple__560)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__560); + __Pyx_GIVEREF(__pyx_tuple__560); + __pyx_codeobj__561 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__560, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNDomchg, 782, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__561)) __PYX_ERR(0, 782, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":790 + * return nbranchings, nconsprop, nprop + * + * def getDomchg(self): # <<<<<<<<<<<<<< + * """Retrieve domain changes for this node.""" + * cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node) + */ + __pyx_tuple__562 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_domchg); if (unlikely(!__pyx_tuple__562)) __PYX_ERR(0, 790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__562); + __Pyx_GIVEREF(__pyx_tuple__562); + __pyx_codeobj__563 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__562, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDomchg, 790, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__563)) __PYX_ERR(0, 790, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__564 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__564)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_node cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__565 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__565)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":821 + * return cname.decode('utf-8') + * + * def ptr(self): # <<<<<<<<<<<<<< + * """ """ + * return (self.scip_var) + */ + __pyx_codeobj__566 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_ptr, 821, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__566)) __PYX_ERR(0, 821, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":828 + * return self.name + * + * def vtype(self): # <<<<<<<<<<<<<< + * """Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)""" + * vartype = SCIPvarGetType(self.scip_var) + */ + __pyx_tuple__567 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_vartype); if (unlikely(!__pyx_tuple__567)) __PYX_ERR(0, 828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__567); + __Pyx_GIVEREF(__pyx_tuple__567); + __pyx_codeobj__568 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__567, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_vtype, 828, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__568)) __PYX_ERR(0, 828, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":840 + * return "IMPLINT" + * + * def isOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve whether the variable belongs to the original problem""" + * return SCIPvarIsOriginal(self.scip_var) + */ + __pyx_codeobj__569 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isOriginal, 840, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__569)) __PYX_ERR(0, 840, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":844 + * return SCIPvarIsOriginal(self.scip_var) + * + * def isInLP(self): # <<<<<<<<<<<<<< + * """Retrieve whether the variable is a COLUMN variable that is member of the current LP""" + * return SCIPvarIsInLP(self.scip_var) + */ + __pyx_codeobj__570 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isInLP, 844, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__570)) __PYX_ERR(0, 844, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":849 + * + * + * def getIndex(self): # <<<<<<<<<<<<<< + * """Retrieve the unique index of the variable.""" + * return SCIPvarGetIndex(self.scip_var) + */ + __pyx_codeobj__571 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getIndex, 849, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__571)) __PYX_ERR(0, 849, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":853 + * return SCIPvarGetIndex(self.scip_var) + * + * def getCol(self): # <<<<<<<<<<<<<< + * """Retrieve column of COLUMN variable""" + * cdef SCIP_COL* scip_col + */ + __pyx_tuple__572 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_scip_col); if (unlikely(!__pyx_tuple__572)) __PYX_ERR(0, 853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__572); + __Pyx_GIVEREF(__pyx_tuple__572); + __pyx_codeobj__573 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__572, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getCol, 853, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__573)) __PYX_ERR(0, 853, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":859 + * return Column.create(scip_col) + * + * def getLbOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve original lower bound of variable""" + * return SCIPvarGetLbOriginal(self.scip_var) + */ + __pyx_codeobj__574 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLbOriginal, 859, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__574)) __PYX_ERR(0, 859, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":863 + * return SCIPvarGetLbOriginal(self.scip_var) + * + * def getUbOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve original upper bound of variable""" + * return SCIPvarGetUbOriginal(self.scip_var) + */ + __pyx_codeobj__575 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getUbOriginal, 863, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__575)) __PYX_ERR(0, 863, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":867 + * return SCIPvarGetUbOriginal(self.scip_var) + * + * def getLbGlobal(self): # <<<<<<<<<<<<<< + * """Retrieve global lower bound of variable""" + * return SCIPvarGetLbGlobal(self.scip_var) + */ + __pyx_codeobj__576 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLbGlobal, 867, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__576)) __PYX_ERR(0, 867, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":871 + * return SCIPvarGetLbGlobal(self.scip_var) + * + * def getUbGlobal(self): # <<<<<<<<<<<<<< + * """Retrieve global upper bound of variable""" + * return SCIPvarGetUbGlobal(self.scip_var) + */ + __pyx_codeobj__577 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getUbGlobal, 871, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__577)) __PYX_ERR(0, 871, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":875 + * return SCIPvarGetUbGlobal(self.scip_var) + * + * def getLbLocal(self): # <<<<<<<<<<<<<< + * """Retrieve current lower bound of variable""" + * return SCIPvarGetLbLocal(self.scip_var) + */ + __pyx_codeobj__578 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLbLocal, 875, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__578)) __PYX_ERR(0, 875, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":879 + * return SCIPvarGetLbLocal(self.scip_var) + * + * def getUbLocal(self): # <<<<<<<<<<<<<< + * """Retrieve current upper bound of variable""" + * return SCIPvarGetUbLocal(self.scip_var) + */ + __pyx_codeobj__579 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getUbLocal, 879, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__579)) __PYX_ERR(0, 879, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":883 + * return SCIPvarGetUbLocal(self.scip_var) + * + * def getObj(self): # <<<<<<<<<<<<<< + * """Retrieve current objective value of variable""" + * return SCIPvarGetObj(self.scip_var) + */ + __pyx_codeobj__580 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getObj, 883, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__580)) __PYX_ERR(0, 883, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":887 + * return SCIPvarGetObj(self.scip_var) + * + * def getLPSol(self): # <<<<<<<<<<<<<< + * """Retrieve the current LP solution value of variable""" + * return SCIPvarGetLPSol(self.scip_var) + */ + __pyx_codeobj__581 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPSol, 887, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__581)) __PYX_ERR(0, 887, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__582 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__582)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_var cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__583 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__583)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":910 + * return self.name + * + * def isOriginal(self): # <<<<<<<<<<<<<< + * """Retrieve whether the constraint belongs to the original problem""" + * return SCIPconsIsOriginal(self.scip_cons) + */ + __pyx_codeobj__584 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isOriginal, 910, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__584)) __PYX_ERR(0, 910, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":914 + * return SCIPconsIsOriginal(self.scip_cons) + * + * def isInitial(self): # <<<<<<<<<<<<<< + * """Retrieve True if the relaxation of the constraint should be in the initial LP""" + * return SCIPconsIsInitial(self.scip_cons) + */ + __pyx_codeobj__585 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isInitial, 914, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__585)) __PYX_ERR(0, 914, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":918 + * return SCIPconsIsInitial(self.scip_cons) + * + * def isSeparated(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be separated during LP processing""" + * return SCIPconsIsSeparated(self.scip_cons) + */ + __pyx_codeobj__586 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isSeparated, 918, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__586)) __PYX_ERR(0, 918, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":922 + * return SCIPconsIsSeparated(self.scip_cons) + * + * def isEnforced(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be enforced during node processing""" + * return SCIPconsIsEnforced(self.scip_cons) + */ + __pyx_codeobj__587 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isEnforced, 922, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__587)) __PYX_ERR(0, 922, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":926 + * return SCIPconsIsEnforced(self.scip_cons) + * + * def isChecked(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be checked for feasibility""" + * return SCIPconsIsChecked(self.scip_cons) + */ + __pyx_codeobj__588 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isChecked, 926, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__588)) __PYX_ERR(0, 926, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":930 + * return SCIPconsIsChecked(self.scip_cons) + * + * def isPropagated(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint should be propagated during node processing""" + * return SCIPconsIsPropagated(self.scip_cons) + */ + __pyx_codeobj__589 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isPropagated, 930, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__589)) __PYX_ERR(0, 930, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":934 + * return SCIPconsIsPropagated(self.scip_cons) + * + * def isLocal(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is only locally valid or not added to any (sub)problem""" + * return SCIPconsIsLocal(self.scip_cons) + */ + __pyx_codeobj__590 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isLocal, 934, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__590)) __PYX_ERR(0, 934, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":938 + * return SCIPconsIsLocal(self.scip_cons) + * + * def isModifiable(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is modifiable (subject to column generation)""" + * return SCIPconsIsModifiable(self.scip_cons) + */ + __pyx_codeobj__591 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isModifiable, 938, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__591)) __PYX_ERR(0, 938, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":942 + * return SCIPconsIsModifiable(self.scip_cons) + * + * def isDynamic(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is subject to aging""" + * return SCIPconsIsDynamic(self.scip_cons) + */ + __pyx_codeobj__592 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isDynamic, 942, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__592)) __PYX_ERR(0, 942, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":946 + * return SCIPconsIsDynamic(self.scip_cons) + * + * def isRemovable(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint's relaxation should be removed from the LP due to aging or cleanup""" + * return SCIPconsIsRemovable(self.scip_cons) + */ + __pyx_codeobj__593 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isRemovable, 946, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__593)) __PYX_ERR(0, 946, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":950 + * return SCIPconsIsRemovable(self.scip_cons) + * + * def isStickingAtNode(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is only locally valid or not added to any (sub)problem""" + * return SCIPconsIsStickingAtNode(self.scip_cons) + */ + __pyx_codeobj__594 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isStickingAtNode, 950, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__594)) __PYX_ERR(0, 950, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":954 + * return SCIPconsIsStickingAtNode(self.scip_cons) + * + * def isActive(self): # <<<<<<<<<<<<<< + * """returns True iff constraint is active in the current node""" + * return SCIPconsIsActive(self.scip_cons) + */ + __pyx_codeobj__595 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isActive, 954, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__595)) __PYX_ERR(0, 954, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":958 + * return SCIPconsIsActive(self.scip_cons) + * + * def isLinear(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is linear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + __pyx_tuple__596 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_constype); if (unlikely(!__pyx_tuple__596)) __PYX_ERR(0, 958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__596); + __Pyx_GIVEREF(__pyx_tuple__596); + __pyx_codeobj__597 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__596, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isLinear, 958, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__597)) __PYX_ERR(0, 958, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":963 + * return constype == 'linear' + * + * def isNonlinear(self): # <<<<<<<<<<<<<< + * """Retrieve True if constraint is nonlinear""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + __pyx_codeobj__598 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__596, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isNonlinear, 963, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__598)) __PYX_ERR(0, 963, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":968 + * return constype == 'nonlinear' + * + * def getConshdlrName(self): # <<<<<<<<<<<<<< + * """Return the constraint handler's name""" + * constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8') + */ + __pyx_codeobj__599 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__596, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getConshdlrName, 968, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__599)) __PYX_ERR(0, 968, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__600 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__600)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__601 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__601)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1073 + * self._freescip = val + * + * @cython.always_allow_keywords(True) # <<<<<<<<<<<<<< + * @staticmethod + * def from_ptr(capsule, take_ownership): + */ + __pyx_tuple__602 = PyTuple_Pack(3, __pyx_n_s_capsule, __pyx_n_s_take_ownership, __pyx_n_s_model); if (unlikely(!__pyx_tuple__602)) __PYX_ERR(0, 1073, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__602); + __Pyx_GIVEREF(__pyx_tuple__602); + __pyx_codeobj__603 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__602, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_from_ptr, 1073, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__603)) __PYX_ERR(0, 1073, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1088 + * return model + * + * @cython.always_allow_keywords(True) # <<<<<<<<<<<<<< + * def to_ptr(self, give_ownership): + * """Return the underlying Scip pointer to the current Model. + */ + __pyx_tuple__604 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_give_ownership, __pyx_n_s_capsule); if (unlikely(!__pyx_tuple__604)) __PYX_ERR(0, 1088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__604); + __Pyx_GIVEREF(__pyx_tuple__604); + __pyx_codeobj__605 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__604, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_to_ptr, 1088, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__605)) __PYX_ERR(0, 1088, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1102 + * return capsule + * + * def includeDefaultPlugins(self): # <<<<<<<<<<<<<< + * """Includes all default plug-ins into SCIP""" + * PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip)) + */ + __pyx_codeobj__606 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeDefaultPlugins, 1102, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__606)) __PYX_ERR(0, 1102, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1106 + * PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip)) + * + * def createProbBasic(self, problemName='model'): # <<<<<<<<<<<<<< + * """Create new problem instance with given name + * + */ + __pyx_tuple__607 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_problemName, __pyx_n_s_n); if (unlikely(!__pyx_tuple__607)) __PYX_ERR(0, 1106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__607); + __Pyx_GIVEREF(__pyx_tuple__607); + __pyx_codeobj__608 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__607, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createProbBasic, 1106, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__608)) __PYX_ERR(0, 1106, __pyx_L1_error) + __pyx_tuple__609 = PyTuple_Pack(1, __pyx_n_u_model); if (unlikely(!__pyx_tuple__609)) __PYX_ERR(0, 1106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__609); + __Pyx_GIVEREF(__pyx_tuple__609); + + /* "src/pyscipopt/scip.pxi":1115 + * PY_SCIP_CALL(SCIPcreateProbBasic(self._scip, n)) + * + * def freeProb(self): # <<<<<<<<<<<<<< + * """Frees problem and solution process data""" + * PY_SCIP_CALL(SCIPfreeProb(self._scip)) + */ + __pyx_codeobj__610 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_freeProb, 1115, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__610)) __PYX_ERR(0, 1115, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1119 + * PY_SCIP_CALL(SCIPfreeProb(self._scip)) + * + * def freeTransform(self): # <<<<<<<<<<<<<< + * """Frees all solution process data including presolving and transformed problem, only original problem is kept""" + * self._modelvars = { + */ + __pyx_tuple__611 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_value); if (unlikely(!__pyx_tuple__611)) __PYX_ERR(0, 1119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__611); + __Pyx_GIVEREF(__pyx_tuple__611); + __pyx_codeobj__612 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__611, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_freeTransform, 1119, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__612)) __PYX_ERR(0, 1119, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1128 + * PY_SCIP_CALL(SCIPfreeTransform(self._scip)) + * + * def version(self): # <<<<<<<<<<<<<< + * """Retrieve SCIP version""" + * return SCIPversion() + */ + __pyx_codeobj__613 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_version, 1128, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__613)) __PYX_ERR(0, 1128, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1132 + * return SCIPversion() + * + * def printVersion(self): # <<<<<<<<<<<<<< + * """Print version, copyright information and compile mode""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + __pyx_tuple__614 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_user_locale); if (unlikely(!__pyx_tuple__614)) __PYX_ERR(0, 1132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__614); + __Pyx_GIVEREF(__pyx_tuple__614); + __pyx_codeobj__615 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__614, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_printVersion, 1132, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__615)) __PYX_ERR(0, 1132, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1141 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def printExternalCodeVersions(self): # <<<<<<<<<<<<<< + * """Print external code versions, e.g. symmetry, non-linear solver, lp solver""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + __pyx_codeobj__616 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__614, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_printExternalCodeVersions, 1141, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__616)) __PYX_ERR(0, 1141, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1150 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getProbName(self): # <<<<<<<<<<<<<< + * """Retrieve problem name""" + * return bytes(SCIPgetProbName(self._scip)).decode('UTF-8') + */ + __pyx_codeobj__617 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getProbName, 1150, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__617)) __PYX_ERR(0, 1150, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1154 + * return bytes(SCIPgetProbName(self._scip)).decode('UTF-8') + * + * def getTotalTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current total SCIP time in seconds, i.e. the total time since the SCIP instance has been created""" + * return SCIPgetTotalTime(self._scip) + */ + __pyx_codeobj__618 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getTotalTime, 1154, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__618)) __PYX_ERR(0, 1154, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1158 + * return SCIPgetTotalTime(self._scip) + * + * def getSolvingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current solving time in seconds""" + * return SCIPgetSolvingTime(self._scip) + */ + __pyx_codeobj__619 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getSolvingTime, 1158, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__619)) __PYX_ERR(0, 1158, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1162 + * return SCIPgetSolvingTime(self._scip) + * + * def getReadingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the current reading time in seconds""" + * return SCIPgetReadingTime(self._scip) + */ + __pyx_codeobj__620 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getReadingTime, 1162, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__620)) __PYX_ERR(0, 1162, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1166 + * return SCIPgetReadingTime(self._scip) + * + * def getPresolvingTime(self): # <<<<<<<<<<<<<< + * """Retrieve the curernt presolving time in seconds""" + * return SCIPgetPresolvingTime(self._scip) + */ + __pyx_codeobj__621 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getPresolvingTime, 1166, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__621)) __PYX_ERR(0, 1166, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1170 + * return SCIPgetPresolvingTime(self._scip) + * + * def getNLPIterations(self): # <<<<<<<<<<<<<< + * """Retrieve the total number of LP iterations so far.""" + * return SCIPgetNLPIterations(self._scip) + */ + __pyx_codeobj__622 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNLPIterations, 1170, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__622)) __PYX_ERR(0, 1170, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1174 + * return SCIPgetNLPIterations(self._scip) + * + * def getNNodes(self): # <<<<<<<<<<<<<< + * """gets number of processed nodes in current run, including the focus node.""" + * return SCIPgetNNodes(self._scip) + */ + __pyx_codeobj__623 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNNodes, 1174, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__623)) __PYX_ERR(0, 1174, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1178 + * return SCIPgetNNodes(self._scip) + * + * def getNTotalNodes(self): # <<<<<<<<<<<<<< + * """gets number of processed nodes in all runs, including the focus node.""" + * return SCIPgetNTotalNodes(self._scip) + */ + __pyx_codeobj__624 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNTotalNodes, 1178, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__624)) __PYX_ERR(0, 1178, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1182 + * return SCIPgetNTotalNodes(self._scip) + * + * def getNFeasibleLeaves(self): # <<<<<<<<<<<<<< + * """Retrieve number of leaf nodes processed with feasible relaxation solution.""" + * return SCIPgetNFeasibleLeaves(self._scip) + */ + __pyx_codeobj__625 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNFeasibleLeaves, 1182, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__625)) __PYX_ERR(0, 1182, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1186 + * return SCIPgetNFeasibleLeaves(self._scip) + * + * def getNInfeasibleLeaves(self): # <<<<<<<<<<<<<< + * """gets number of infeasible leaf nodes processed.""" + * return SCIPgetNInfeasibleLeaves(self._scip) + */ + __pyx_codeobj__626 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNInfeasibleLeaves, 1186, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__626)) __PYX_ERR(0, 1186, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1190 + * return SCIPgetNInfeasibleLeaves(self._scip) + * + * def getNLeaves(self): # <<<<<<<<<<<<<< + * """gets number of leaves in the tree.""" + * return SCIPgetNLeaves(self._scip) + */ + __pyx_codeobj__627 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNLeaves, 1190, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__627)) __PYX_ERR(0, 1190, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1194 + * return SCIPgetNLeaves(self._scip) + * + * def getNChildren(self): # <<<<<<<<<<<<<< + * """gets number of children of focus node.""" + * return SCIPgetNChildren(self._scip) + */ + __pyx_codeobj__628 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNChildren, 1194, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__628)) __PYX_ERR(0, 1194, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1198 + * return SCIPgetNChildren(self._scip) + * + * def getNSiblings(self): # <<<<<<<<<<<<<< + * """gets number of siblings of focus node.""" + * return SCIPgetNSiblings(self._scip) + */ + __pyx_codeobj__629 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNSiblings, 1198, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__629)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1202 + * return SCIPgetNSiblings(self._scip) + * + * def getCurrentNode(self): # <<<<<<<<<<<<<< + * """Retrieve current node.""" + * return Node.create(SCIPgetCurrentNode(self._scip)) + */ + __pyx_codeobj__630 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getCurrentNode, 1202, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__630)) __PYX_ERR(0, 1202, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1206 + * return Node.create(SCIPgetCurrentNode(self._scip)) + * + * def getGap(self): # <<<<<<<<<<<<<< + * """Retrieve the gap, i.e. |(primalbound - dualbound)/min(|primalbound|,|dualbound|)|.""" + * return SCIPgetGap(self._scip) + */ + __pyx_codeobj__631 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getGap, 1206, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__631)) __PYX_ERR(0, 1206, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1210 + * return SCIPgetGap(self._scip) + * + * def getDepth(self): # <<<<<<<<<<<<<< + * """Retrieve the depth of the current node""" + * return SCIPgetDepth(self._scip) + */ + __pyx_codeobj__632 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDepth, 1210, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__632)) __PYX_ERR(0, 1210, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1214 + * return SCIPgetDepth(self._scip) + * + * def infinity(self): # <<<<<<<<<<<<<< + * """Retrieve SCIP's infinity value""" + * return SCIPinfinity(self._scip) + */ + __pyx_codeobj__633 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_infinity, 1214, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__633)) __PYX_ERR(0, 1214, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1218 + * return SCIPinfinity(self._scip) + * + * def epsilon(self): # <<<<<<<<<<<<<< + * """Retrieve epsilon for e.g. equality checks""" + * return SCIPepsilon(self._scip) + */ + __pyx_codeobj__634 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_epsilon, 1218, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__634)) __PYX_ERR(0, 1218, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1222 + * return SCIPepsilon(self._scip) + * + * def feastol(self): # <<<<<<<<<<<<<< + * """Retrieve feasibility tolerance""" + * return SCIPfeastol(self._scip) + */ + __pyx_codeobj__635 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_feastol, 1222, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__635)) __PYX_ERR(0, 1222, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1226 + * return SCIPfeastol(self._scip) + * + * def feasFrac(self, value): # <<<<<<<<<<<<<< + * """returns fractional part of value, i.e. x - floor(x) in feasible tolerance: x - floor(x+feastol)""" + * return SCIPfeasFrac(self._scip, value) + */ + __pyx_tuple__636 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_value); if (unlikely(!__pyx_tuple__636)) __PYX_ERR(0, 1226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__636); + __Pyx_GIVEREF(__pyx_tuple__636); + __pyx_codeobj__637 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__636, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_feasFrac, 1226, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__637)) __PYX_ERR(0, 1226, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1230 + * return SCIPfeasFrac(self._scip, value) + * + * def frac(self, value): # <<<<<<<<<<<<<< + * """returns fractional part of value, i.e. x - floor(x) in epsilon tolerance: x - floor(x+eps)""" + * return SCIPfrac(self._scip, value) + */ + __pyx_codeobj__638 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__636, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_frac, 1230, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__638)) __PYX_ERR(0, 1230, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1234 + * return SCIPfrac(self._scip, value) + * + * def isZero(self, value): # <<<<<<<<<<<<<< + * """returns whether abs(value) < eps""" + * return SCIPisZero(self._scip, value) + */ + __pyx_codeobj__639 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__636, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isZero, 1234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__639)) __PYX_ERR(0, 1234, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1238 + * return SCIPisZero(self._scip, value) + * + * def isFeasZero(self, value): # <<<<<<<<<<<<<< + * """returns whether abs(value) < feastol""" + * return SCIPisFeasZero(self._scip, value) + */ + __pyx_codeobj__640 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__636, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isFeasZero, 1238, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__640)) __PYX_ERR(0, 1238, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1242 + * return SCIPisFeasZero(self._scip, value) + * + * def isInfinity(self, value): # <<<<<<<<<<<<<< + * """returns whether value is SCIP's infinity""" + * return SCIPisInfinity(self._scip, value) + */ + __pyx_codeobj__641 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__636, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isInfinity, 1242, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__641)) __PYX_ERR(0, 1242, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1246 + * return SCIPisInfinity(self._scip, value) + * + * def isFeasNegative(self, value): # <<<<<<<<<<<<<< + * """returns whether value < -feastol""" + * return SCIPisFeasNegative(self._scip, value) + */ + __pyx_codeobj__642 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__636, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isFeasNegative, 1246, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__642)) __PYX_ERR(0, 1246, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1250 + * return SCIPisFeasNegative(self._scip, value) + * + * def isFeasIntegral(self, value): # <<<<<<<<<<<<<< + * """returns whether value is integral within the LP feasibility bounds""" + * return SCIPisFeasIntegral(self._scip, value) + */ + __pyx_codeobj__643 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__636, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isFeasIntegral, 1250, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__643)) __PYX_ERR(0, 1250, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1254 + * return SCIPisFeasIntegral(self._scip, value) + * + * def isEQ(self, val1, val2): # <<<<<<<<<<<<<< + * """checks, if values are in range of epsilon""" + * return SCIPisEQ(self._scip, val1, val2) + */ + __pyx_tuple__644 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_val1, __pyx_n_s_val2); if (unlikely(!__pyx_tuple__644)) __PYX_ERR(0, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__644); + __Pyx_GIVEREF(__pyx_tuple__644); + __pyx_codeobj__645 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__644, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isEQ, 1254, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__645)) __PYX_ERR(0, 1254, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1258 + * return SCIPisEQ(self._scip, val1, val2) + * + * def isFeasEQ(self, val1, val2): # <<<<<<<<<<<<<< + * """checks, if relative difference of values is in range of feasibility tolerance""" + * return SCIPisFeasEQ(self._scip, val1, val2) + */ + __pyx_codeobj__646 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__644, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isFeasEQ, 1258, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__646)) __PYX_ERR(0, 1258, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1262 + * return SCIPisFeasEQ(self._scip, val1, val2) + * + * def isLE(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 <= val2 + eps""" + * return SCIPisLE(self._scip, val1, val2) + */ + __pyx_codeobj__647 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__644, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isLE, 1262, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__647)) __PYX_ERR(0, 1262, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1266 + * return SCIPisLE(self._scip, val1, val2) + * + * def isLT(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 < val2 - eps""" + * return SCIPisLT(self._scip, val1, val2) + */ + __pyx_codeobj__648 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__644, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isLT, 1266, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__648)) __PYX_ERR(0, 1266, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1270 + * return SCIPisLT(self._scip, val1, val2) + * + * def isGE(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 >= val2 - eps""" + * return SCIPisGE(self._scip, val1, val2) + */ + __pyx_codeobj__649 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__644, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isGE, 1270, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__649)) __PYX_ERR(0, 1270, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1274 + * return SCIPisGE(self._scip, val1, val2) + * + * def isGT(self, val1, val2): # <<<<<<<<<<<<<< + * """returns whether val1 > val2 + eps""" + * return SCIPisGT(self._scip, val1, val2) + */ + __pyx_codeobj__650 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__644, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isGT, 1274, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__650)) __PYX_ERR(0, 1274, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1278 + * return SCIPisGT(self._scip, val1, val2) + * + * def getCondition(self, exact=False): # <<<<<<<<<<<<<< + * """Get the current LP's condition number + * + */ + __pyx_tuple__651 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_exact, __pyx_n_s_lpi, __pyx_n_s_quality); if (unlikely(!__pyx_tuple__651)) __PYX_ERR(0, 1278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__651); + __Pyx_GIVEREF(__pyx_tuple__651); + __pyx_codeobj__652 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__651, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getCondition, 1278, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__652)) __PYX_ERR(0, 1278, __pyx_L1_error) + __pyx_tuple__653 = PyTuple_Pack(1, Py_False); if (unlikely(!__pyx_tuple__653)) __PYX_ERR(0, 1278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__653); + __Pyx_GIVEREF(__pyx_tuple__653); + + /* "src/pyscipopt/scip.pxi":1294 + * return quality + * + * def enableReoptimization(self, enable=True): # <<<<<<<<<<<<<< + * """include specific heuristics and branching rules for reoptimization""" + * PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable)) + */ + __pyx_tuple__654 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_enable); if (unlikely(!__pyx_tuple__654)) __PYX_ERR(0, 1294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__654); + __Pyx_GIVEREF(__pyx_tuple__654); + __pyx_codeobj__655 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__654, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_enableReoptimization, 1294, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__655)) __PYX_ERR(0, 1294, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1298 + * PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable)) + * + * def lpiGetIterations(self): # <<<<<<<<<<<<<< + * """Get the iteration count of the last solved LP""" + * cdef SCIP_LPI* lpi + */ + __pyx_tuple__656 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_lpi, __pyx_n_s_iters); if (unlikely(!__pyx_tuple__656)) __PYX_ERR(0, 1298, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__656); + __Pyx_GIVEREF(__pyx_tuple__656); + __pyx_codeobj__657 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__656, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_lpiGetIterations, 1298, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__657)) __PYX_ERR(0, 1298, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1308 + * # Objective function + * + * def setMinimize(self): # <<<<<<<<<<<<<< + * """Set the objective sense to minimization.""" + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE)) + */ + __pyx_codeobj__658 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setMinimize, 1308, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__658)) __PYX_ERR(0, 1308, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1312 + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE)) + * + * def setMaximize(self): # <<<<<<<<<<<<<< + * """Set the objective sense to maximization.""" + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE)) + */ + __pyx_codeobj__659 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setMaximize, 1312, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__659)) __PYX_ERR(0, 1312, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1316 + * PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE)) + * + * def setObjlimit(self, objlimit): # <<<<<<<<<<<<<< + * """Set a limit on the objective function. + * Only solutions with objective value better than this limit are accepted. + */ + __pyx_tuple__660 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_objlimit); if (unlikely(!__pyx_tuple__660)) __PYX_ERR(0, 1316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__660); + __Pyx_GIVEREF(__pyx_tuple__660); + __pyx_codeobj__661 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__660, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setObjlimit, 1316, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__661)) __PYX_ERR(0, 1316, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1325 + * PY_SCIP_CALL(SCIPsetObjlimit(self._scip, objlimit)) + * + * def getObjlimit(self): # <<<<<<<<<<<<<< + * """returns current limit on objective function.""" + * return SCIPgetObjlimit(self._scip) + */ + __pyx_codeobj__662 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getObjlimit, 1325, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__662)) __PYX_ERR(0, 1325, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1329 + * return SCIPgetObjlimit(self._scip) + * + * def setObjective(self, expr, sense = 'minimize', clear = 'true'): # <<<<<<<<<<<<<< + * """Establish the objective function as a linear expression. + * + */ + __pyx_tuple__663 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_expr, __pyx_n_s_sense, __pyx_n_s_clear, __pyx_n_s_vars_2, __pyx_n_s_nvars_2, __pyx_n_s_i, __pyx_n_s_term, __pyx_n_s_coef, __pyx_n_s_var); if (unlikely(!__pyx_tuple__663)) __PYX_ERR(0, 1329, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__663); + __Pyx_GIVEREF(__pyx_tuple__663); + __pyx_codeobj__664 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__663, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setObjective, 1329, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__664)) __PYX_ERR(0, 1329, __pyx_L1_error) + __pyx_tuple__665 = PyTuple_Pack(2, __pyx_n_u_minimize, __pyx_n_u_true); if (unlikely(!__pyx_tuple__665)) __PYX_ERR(0, 1329, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__665); + __Pyx_GIVEREF(__pyx_tuple__665); + + /* "src/pyscipopt/scip.pxi":1374 + * raise Warning("unrecognized optimization sense: %s" % sense) + * + * def getObjective(self): # <<<<<<<<<<<<<< + * """Retrieve objective function as Expr""" + * variables = self.getVars() + */ + __pyx_tuple__666 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_variables, __pyx_n_s_objective, __pyx_n_s_var, __pyx_n_s_coeff); if (unlikely(!__pyx_tuple__666)) __PYX_ERR(0, 1374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__666); + __Pyx_GIVEREF(__pyx_tuple__666); + __pyx_codeobj__667 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__666, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getObjective, 1374, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__667)) __PYX_ERR(0, 1374, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1385 + * return objective + * + * def addObjoffset(self, offset, solutions = False): # <<<<<<<<<<<<<< + * """Add constant offset to objective + * + */ + __pyx_tuple__668 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_offset, __pyx_n_s_solutions); if (unlikely(!__pyx_tuple__668)) __PYX_ERR(0, 1385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__668); + __Pyx_GIVEREF(__pyx_tuple__668); + __pyx_codeobj__669 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__668, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addObjoffset, 1385, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__669)) __PYX_ERR(0, 1385, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1397 + * PY_SCIP_CALL(SCIPaddOrigObjoffset(self._scip, offset)) + * + * def getObjoffset(self, original = True): # <<<<<<<<<<<<<< + * """Retrieve constant objective offset + * + */ + __pyx_tuple__670 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_original); if (unlikely(!__pyx_tuple__670)) __PYX_ERR(0, 1397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__670); + __Pyx_GIVEREF(__pyx_tuple__670); + __pyx_codeobj__671 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__670, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getObjoffset, 1397, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__671)) __PYX_ERR(0, 1397, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1408 + * return SCIPgetTransObjoffset(self._scip) + * + * def setObjIntegral(self): # <<<<<<<<<<<<<< + * """informs SCIP that the objective value is always integral in every feasible solution + * Note: This function should be used to inform SCIP that the objective function is integral, helping to improve the + */ + __pyx_codeobj__672 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setObjIntegral, 1408, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__672)) __PYX_ERR(0, 1408, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1418 + * PY_SCIP_CALL(SCIPsetObjIntegral(self._scip)) + * + * def getLocalEstimate(self, original = False): # <<<<<<<<<<<<<< + * """gets estimate of best primal solution w.r.t. original or transformed problem contained in current subtree + * + */ + __pyx_codeobj__673 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__670, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLocalEstimate, 1418, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__673)) __PYX_ERR(0, 1418, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1429 + * + * # Setting parameters + * def setPresolve(self, setting): # <<<<<<<<<<<<<< + * """Set presolving parameter settings. + * + */ + __pyx_tuple__674 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_setting); if (unlikely(!__pyx_tuple__674)) __PYX_ERR(0, 1429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__674); + __Pyx_GIVEREF(__pyx_tuple__674); + __pyx_codeobj__675 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__674, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setPresolve, 1429, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__675)) __PYX_ERR(0, 1429, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1437 + * PY_SCIP_CALL(SCIPsetPresolving(self._scip, setting, True)) + * + * def setProbName(self, name): # <<<<<<<<<<<<<< + * """Set problem name""" + * n = str_conversion(name) + */ + __pyx_tuple__676 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_n); if (unlikely(!__pyx_tuple__676)) __PYX_ERR(0, 1437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__676); + __Pyx_GIVEREF(__pyx_tuple__676); + __pyx_codeobj__677 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__676, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setProbName, 1437, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__677)) __PYX_ERR(0, 1437, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1442 + * PY_SCIP_CALL(SCIPsetProbName(self._scip, n)) + * + * def setSeparating(self, setting): # <<<<<<<<<<<<<< + * """Set separating parameter settings. + * + */ + __pyx_codeobj__678 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__674, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setSeparating, 1442, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__678)) __PYX_ERR(0, 1442, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1450 + * PY_SCIP_CALL(SCIPsetSeparating(self._scip, setting, True)) + * + * def setHeuristics(self, setting): # <<<<<<<<<<<<<< + * """Set heuristics parameter settings. + * + */ + __pyx_codeobj__679 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__674, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setHeuristics, 1450, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__679)) __PYX_ERR(0, 1450, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1458 + * PY_SCIP_CALL(SCIPsetHeuristics(self._scip, setting, True)) + * + * def disablePropagation(self, onlyroot=False): # <<<<<<<<<<<<<< + * """Disables propagation in SCIP to avoid modifying the original problem during transformation. + * + */ + __pyx_tuple__680 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_onlyroot); if (unlikely(!__pyx_tuple__680)) __PYX_ERR(0, 1458, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__680); + __Pyx_GIVEREF(__pyx_tuple__680); + __pyx_codeobj__681 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__680, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_disablePropagation, 1458, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__681)) __PYX_ERR(0, 1458, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1468 + * self.setIntParam("propagating/maxrounds", 0) + * + * def writeProblem(self, filename='model.cip', trans=False, genericnames=False, verbose=True): # <<<<<<<<<<<<<< + * """Write current model/problem to a file. + * + */ + __pyx_tuple__682 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_trans, __pyx_n_s_genericnames, __pyx_n_s_verbose, __pyx_n_s_user_locale, __pyx_n_s_str_absfile, __pyx_n_s_absfile, __pyx_n_s_fn, __pyx_n_s_ext); if (unlikely(!__pyx_tuple__682)) __PYX_ERR(0, 1468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__682); + __Pyx_GIVEREF(__pyx_tuple__682); + __pyx_codeobj__683 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__682, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeProblem, 1468, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__683)) __PYX_ERR(0, 1468, __pyx_L1_error) + __pyx_tuple__684 = PyTuple_Pack(4, __pyx_kp_u_model_cip, Py_False, Py_False, Py_True); if (unlikely(!__pyx_tuple__684)) __PYX_ERR(0, 1468, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__684); + __Pyx_GIVEREF(__pyx_tuple__684); + + /* "src/pyscipopt/scip.pxi":1500 + * # Variable Functions + * + * def addVar(self, name='', vtype='C', lb=0.0, ub=None, obj=0.0, pricedVar=False, pricedVarScore=1.0): # <<<<<<<<<<<<<< + * """Create a new variable. Default variable is non-negative and continuous. + * + */ + __pyx_tuple__685 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_vtype, __pyx_n_s_lb, __pyx_n_s_ub, __pyx_n_s_obj, __pyx_n_s_pricedVar, __pyx_n_s_pricedVarScore, __pyx_n_s_scip_var, __pyx_n_s_cname, __pyx_n_s_pyVar); if (unlikely(!__pyx_tuple__685)) __PYX_ERR(0, 1500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__685); + __Pyx_GIVEREF(__pyx_tuple__685); + __pyx_codeobj__686 = (PyObject*)__Pyx_PyCode_New(8, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__685, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addVar, 1500, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__686)) __PYX_ERR(0, 1500, __pyx_L1_error) + __pyx_tuple__687 = PyTuple_Pack(7, __pyx_kp_u__89, __pyx_n_u_C, __pyx_float_0_0, Py_None, __pyx_float_0_0, Py_False, __pyx_float_1_0); if (unlikely(!__pyx_tuple__687)) __PYX_ERR(0, 1500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__687); + __Pyx_GIVEREF(__pyx_tuple__687); + + /* "src/pyscipopt/scip.pxi":1558 + * return pyVar + * + * def getTransformedVar(self, Variable var): # <<<<<<<<<<<<<< + * """Retrieve the transformed variable. + * + */ + __pyx_tuple__688 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_tvar); if (unlikely(!__pyx_tuple__688)) __PYX_ERR(0, 1558, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__688); + __Pyx_GIVEREF(__pyx_tuple__688); + __pyx_codeobj__689 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__688, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getTransformedVar, 1558, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__689)) __PYX_ERR(0, 1558, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1569 + * return Variable.create(_tvar) + * + * def addVarLocks(self, Variable var, nlocksdown, nlocksup): # <<<<<<<<<<<<<< + * """adds given values to lock numbers of variable for rounding + * + */ + __pyx_tuple__690 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_nlocksdown, __pyx_n_s_nlocksup); if (unlikely(!__pyx_tuple__690)) __PYX_ERR(0, 1569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__690); + __Pyx_GIVEREF(__pyx_tuple__690); + __pyx_codeobj__691 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__690, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addVarLocks, 1569, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__691)) __PYX_ERR(0, 1569, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1579 + * PY_SCIP_CALL(SCIPaddVarLocks(self._scip, var.scip_var, nlocksdown, nlocksup)) + * + * def fixVar(self, Variable var, val): # <<<<<<<<<<<<<< + * """Fixes the variable var to the value val if possible. + * + */ + __pyx_tuple__692 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_val, __pyx_n_s_infeasible, __pyx_n_s_fixed); if (unlikely(!__pyx_tuple__692)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__692); + __Pyx_GIVEREF(__pyx_tuple__692); + __pyx_codeobj__693 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__692, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_fixVar, 1579, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__693)) __PYX_ERR(0, 1579, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1592 + * return infeasible, fixed + * + * def delVar(self, Variable var): # <<<<<<<<<<<<<< + * """Delete a variable. + * + */ + __pyx_tuple__694 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_deleted); if (unlikely(!__pyx_tuple__694)) __PYX_ERR(0, 1592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__694); + __Pyx_GIVEREF(__pyx_tuple__694); + __pyx_codeobj__695 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__694, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_delVar, 1592, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__695)) __PYX_ERR(0, 1592, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1605 + * return deleted + * + * def tightenVarLb(self, Variable var, lb, force=False): # <<<<<<<<<<<<<< + * """Tighten the lower bound in preprocessing or current node, if the bound is tighter. + * + */ + __pyx_tuple__696 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_lb, __pyx_n_s_force, __pyx_n_s_infeasible, __pyx_n_s_tightened); if (unlikely(!__pyx_tuple__696)) __PYX_ERR(0, 1605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__696); + __Pyx_GIVEREF(__pyx_tuple__696); + __pyx_codeobj__697 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__696, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_tightenVarLb, 1605, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__697)) __PYX_ERR(0, 1605, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1621 + * return infeasible, tightened + * + * def tightenVarUb(self, Variable var, ub, force=False): # <<<<<<<<<<<<<< + * """Tighten the upper bound in preprocessing or current node, if the bound is tighter. + * + */ + __pyx_tuple__698 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_ub, __pyx_n_s_force, __pyx_n_s_infeasible, __pyx_n_s_tightened); if (unlikely(!__pyx_tuple__698)) __PYX_ERR(0, 1621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__698); + __Pyx_GIVEREF(__pyx_tuple__698); + __pyx_codeobj__699 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__698, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_tightenVarUb, 1621, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__699)) __PYX_ERR(0, 1621, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1637 + * return infeasible, tightened + * + * def tightenVarUbGlobal(self, Variable var, ub, force=False): # <<<<<<<<<<<<<< + * """Tighten the global upper bound, if the bound is tighter. + * + */ + __pyx_codeobj__700 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__698, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_tightenVarUbGlobal, 1637, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__700)) __PYX_ERR(0, 1637, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1653 + * return infeasible, tightened + * + * def tightenVarLbGlobal(self, Variable var, lb, force=False): # <<<<<<<<<<<<<< + * """Tighten the global upper bound, if the bound is tighter. + * + */ + __pyx_codeobj__701 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__696, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_tightenVarLbGlobal, 1653, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__701)) __PYX_ERR(0, 1653, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1669 + * return infeasible, tightened + * + * def chgVarLb(self, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the lower bound of the specified variable. + * + */ + __pyx_tuple__702 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_lb); if (unlikely(!__pyx_tuple__702)) __PYX_ERR(0, 1669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__702); + __Pyx_GIVEREF(__pyx_tuple__702); + __pyx_codeobj__703 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__702, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarLb, 1669, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__703)) __PYX_ERR(0, 1669, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1680 + * PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb)) + * + * def chgVarUb(self, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the upper bound of the specified variable. + * + */ + __pyx_tuple__704 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_ub); if (unlikely(!__pyx_tuple__704)) __PYX_ERR(0, 1680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__704); + __Pyx_GIVEREF(__pyx_tuple__704); + __pyx_codeobj__705 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__704, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarUb, 1680, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__705)) __PYX_ERR(0, 1680, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1691 + * PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub)) + * + * def chgVarLbGlobal(self, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the global lower bound of the specified variable. + * + */ + __pyx_codeobj__706 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__702, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarLbGlobal, 1691, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__706)) __PYX_ERR(0, 1691, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1702 + * PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb)) + * + * def chgVarUbGlobal(self, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the global upper bound of the specified variable. + * + */ + __pyx_codeobj__707 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__704, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarUbGlobal, 1702, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__707)) __PYX_ERR(0, 1702, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1713 + * PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub)) + * + * def chgVarLbNode(self, Node node, Variable var, lb): # <<<<<<<<<<<<<< + * """Changes the lower bound of the specified variable at the given node. + * + */ + __pyx_tuple__708 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_node, __pyx_n_s_var, __pyx_n_s_lb); if (unlikely(!__pyx_tuple__708)) __PYX_ERR(0, 1713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__708); + __Pyx_GIVEREF(__pyx_tuple__708); + __pyx_codeobj__709 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__708, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarLbNode, 1713, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__709)) __PYX_ERR(0, 1713, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1724 + * PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb)) + * + * def chgVarUbNode(self, Node node, Variable var, ub): # <<<<<<<<<<<<<< + * """Changes the upper bound of the specified variable at the given node. + * + */ + __pyx_tuple__710 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_node, __pyx_n_s_var, __pyx_n_s_ub); if (unlikely(!__pyx_tuple__710)) __PYX_ERR(0, 1724, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__710); + __Pyx_GIVEREF(__pyx_tuple__710); + __pyx_codeobj__711 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__710, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarUbNode, 1724, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__711)) __PYX_ERR(0, 1724, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1735 + * PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub)) + * + * def chgVarType(self, Variable var, vtype): # <<<<<<<<<<<<<< + * """Changes the type of a variable + * + */ + __pyx_tuple__712 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_vtype, __pyx_n_s_infeasible); if (unlikely(!__pyx_tuple__712)) __PYX_ERR(0, 1735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__712); + __Pyx_GIVEREF(__pyx_tuple__712); + __pyx_codeobj__713 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__712, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarType, 1735, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__713)) __PYX_ERR(0, 1735, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1756 + * print('could not change variable type of variable %s' % var) + * + * def getVars(self, transformed=False): # <<<<<<<<<<<<<< + * """Retrieve all variables. + * + */ + __pyx_tuple__714 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_transformed, __pyx_n_s_vars_2, __pyx_n_s_var_2, __pyx_n_s_nvars_2, __pyx_n_s_vars, __pyx_n_s_i, __pyx_n_s_ptr, __pyx_n_s_var); if (unlikely(!__pyx_tuple__714)) __PYX_ERR(0, 1756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__714); + __Pyx_GIVEREF(__pyx_tuple__714); + __pyx_codeobj__715 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__714, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVars, 1756, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__715)) __PYX_ERR(0, 1756, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1789 + * return vars + * + * def getNVars(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve number of variables in the problems. + * + */ + __pyx_tuple__716 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_transformed); if (unlikely(!__pyx_tuple__716)) __PYX_ERR(0, 1789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__716); + __Pyx_GIVEREF(__pyx_tuple__716); + __pyx_codeobj__717 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__716, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNVars, 1789, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__717)) __PYX_ERR(0, 1789, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1799 + * return SCIPgetNOrigVars(self._scip) + * + * def getNIntVars(self): # <<<<<<<<<<<<<< + * """gets number of integer active problem variables""" + * return SCIPgetNIntVars(self._scip) + */ + __pyx_codeobj__718 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNIntVars, 1799, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__718)) __PYX_ERR(0, 1799, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1803 + * return SCIPgetNIntVars(self._scip) + * + * def getNBinVars(self): # <<<<<<<<<<<<<< + * """gets number of binary active problem variables""" + * return SCIPgetNBinVars(self._scip) + */ + __pyx_codeobj__719 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNBinVars, 1803, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__719)) __PYX_ERR(0, 1803, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1807 + * return SCIPgetNBinVars(self._scip) + * + * def getVarDict(self): # <<<<<<<<<<<<<< + * """gets dictionary with variables names as keys and current variable values as items""" + * var_dict = {} + */ + __pyx_tuple__720 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var_dict, __pyx_n_s_var); if (unlikely(!__pyx_tuple__720)) __PYX_ERR(0, 1807, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__720); + __Pyx_GIVEREF(__pyx_tuple__720); + __pyx_codeobj__721 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__720, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVarDict, 1807, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__721)) __PYX_ERR(0, 1807, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1814 + * return var_dict + * + * def updateNodeLowerbound(self, Node node, lb): # <<<<<<<<<<<<<< + * """if given value is larger than the node's lower bound (in transformed problem), + * sets the node's lower bound to the new value + */ + __pyx_tuple__722 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_node, __pyx_n_s_lb); if (unlikely(!__pyx_tuple__722)) __PYX_ERR(0, 1814, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__722); + __Pyx_GIVEREF(__pyx_tuple__722); + __pyx_codeobj__723 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__722, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_updateNodeLowerbound, 1814, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__723)) __PYX_ERR(0, 1814, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1824 + * PY_SCIP_CALL(SCIPupdateNodeLowerbound(self._scip, node.scip_node, lb)) + * + * def relax(self): # <<<<<<<<<<<<<< + * """Relaxes the integrality restrictions of the model""" + * if self.getStage() != SCIP_STAGE_PROBLEM: + */ + __pyx_codeobj__724 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__479, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_relax, 1824, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__724)) __PYX_ERR(0, 1824, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1833 + * + * # Node methods + * def getBestChild(self): # <<<<<<<<<<<<<< + * """gets the best child of the focus node w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestChild(self._scip)) + */ + __pyx_codeobj__725 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBestChild, 1833, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__725)) __PYX_ERR(0, 1833, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1837 + * return Node.create(SCIPgetBestChild(self._scip)) + * + * def getBestSibling(self): # <<<<<<<<<<<<<< + * """gets the best sibling of the focus node w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestSibling(self._scip)) + */ + __pyx_codeobj__726 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBestSibling, 1837, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__726)) __PYX_ERR(0, 1837, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1841 + * return Node.create(SCIPgetBestSibling(self._scip)) + * + * def getBestLeaf(self): # <<<<<<<<<<<<<< + * """gets the best leaf from the node queue w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestLeaf(self._scip)) + */ + __pyx_codeobj__727 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBestLeaf, 1841, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__727)) __PYX_ERR(0, 1841, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1845 + * return Node.create(SCIPgetBestLeaf(self._scip)) + * + * def getBestNode(self): # <<<<<<<<<<<<<< + * """gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy.""" + * return Node.create(SCIPgetBestNode(self._scip)) + */ + __pyx_codeobj__728 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBestNode, 1845, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__728)) __PYX_ERR(0, 1845, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1849 + * return Node.create(SCIPgetBestNode(self._scip)) + * + * def getBestboundNode(self): # <<<<<<<<<<<<<< + * """gets the node with smallest lower bound from the tree (child, sibling, or leaf).""" + * return Node.create(SCIPgetBestboundNode(self._scip)) + */ + __pyx_codeobj__729 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBestboundNode, 1849, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__729)) __PYX_ERR(0, 1849, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1853 + * return Node.create(SCIPgetBestboundNode(self._scip)) + * + * def getOpenNodes(self): # <<<<<<<<<<<<<< + * """access to all data of open nodes (leaves, children, and siblings) + * + */ + __pyx_tuple__730 = PyTuple_Pack(13, __pyx_n_s_self, __pyx_n_s_leaves, __pyx_n_s_children_2, __pyx_n_s_siblings, __pyx_n_s_nleaves, __pyx_n_s_nchildren_2, __pyx_n_s_nsiblings, __pyx_n_s_leaves_2, __pyx_n_s_children, __pyx_n_s_siblings_2, __pyx_n_s_i, __pyx_n_s_i, __pyx_n_s_i); if (unlikely(!__pyx_tuple__730)) __PYX_ERR(0, 1853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__730); + __Pyx_GIVEREF(__pyx_tuple__730); + __pyx_codeobj__731 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__730, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getOpenNodes, 1853, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__731)) __PYX_ERR(0, 1853, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1873 + * return leaves, children, siblings + * + * def repropagateNode(self, Node node): # <<<<<<<<<<<<<< + * """marks the given node to be propagated again the next time a node of its subtree is processed""" + * PY_SCIP_CALL(SCIPrepropagateNode(self._scip, node.scip_node)) + */ + __pyx_codeobj__732 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__481, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_repropagateNode, 1873, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__732)) __PYX_ERR(0, 1873, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1879 + * + * # LP Methods + * def getLPSolstat(self): # <<<<<<<<<<<<<< + * """Gets solution status of current LP""" + * return SCIPgetLPSolstat(self._scip) + */ + __pyx_codeobj__733 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPSolstat, 1879, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__733)) __PYX_ERR(0, 1879, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1884 + * + * + * def constructLP(self): # <<<<<<<<<<<<<< + * """makes sure that the LP of the current node is loaded and + * may be accessed through the LP information methods + */ + __pyx_tuple__734 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_cutoff); if (unlikely(!__pyx_tuple__734)) __PYX_ERR(0, 1884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__734); + __Pyx_GIVEREF(__pyx_tuple__734); + __pyx_codeobj__735 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__734, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_constructLP, 1884, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__735)) __PYX_ERR(0, 1884, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1895 + * return cutoff + * + * def getLPObjVal(self): # <<<<<<<<<<<<<< + * """gets objective value of current LP (which is the sum of column and loose objective value)""" + * + */ + __pyx_codeobj__736 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPObjVal, 1895, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__736)) __PYX_ERR(0, 1895, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1900 + * return SCIPgetLPObjval(self._scip) + * + * def getLPColsData(self): # <<<<<<<<<<<<<< + * """Retrieve current LP columns""" + * cdef SCIP_COL** cols + */ + __pyx_tuple__737 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cols, __pyx_n_s_ncols, __pyx_n_s_i); if (unlikely(!__pyx_tuple__737)) __PYX_ERR(0, 1900, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__737); + __Pyx_GIVEREF(__pyx_tuple__737); + __pyx_codeobj__738 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__737, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPColsData, 1900, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__738)) __PYX_ERR(0, 1900, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1908 + * return [Column.create(cols[i]) for i in range(ncols)] + * + * def getLPRowsData(self): # <<<<<<<<<<<<<< + * """Retrieve current LP rows""" + * cdef SCIP_ROW** rows + */ + __pyx_tuple__739 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_rows, __pyx_n_s_nrows, __pyx_n_s_i); if (unlikely(!__pyx_tuple__739)) __PYX_ERR(0, 1908, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__739); + __Pyx_GIVEREF(__pyx_tuple__739); + __pyx_codeobj__740 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__739, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPRowsData, 1908, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__740)) __PYX_ERR(0, 1908, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1916 + * return [Row.create(rows[i]) for i in range(nrows)] + * + * def getNLPRows(self): # <<<<<<<<<<<<<< + * """Retrieve the number of rows currently in the LP""" + * return SCIPgetNLPRows(self._scip) + */ + __pyx_codeobj__741 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNLPRows, 1916, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__741)) __PYX_ERR(0, 1916, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1920 + * return SCIPgetNLPRows(self._scip) + * + * def getNLPCols(self): # <<<<<<<<<<<<<< + * """Retrieve the number of cols currently in the LP""" + * return SCIPgetNLPCols(self._scip) + */ + __pyx_codeobj__742 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNLPCols, 1920, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__742)) __PYX_ERR(0, 1920, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1924 + * return SCIPgetNLPCols(self._scip) + * + * def getLPBasisInd(self): # <<<<<<<<<<<<<< + * """Gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1""" + * cdef int nrows = SCIPgetNLPRows(self._scip) + */ + __pyx_tuple__743 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_nrows, __pyx_n_s_inds, __pyx_n_s_result, __pyx_n_s_i); if (unlikely(!__pyx_tuple__743)) __PYX_ERR(0, 1924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__743); + __Pyx_GIVEREF(__pyx_tuple__743); + __pyx_codeobj__744 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__743, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPBasisInd, 1924, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__744)) __PYX_ERR(0, 1924, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1934 + * return result + * + * def getLPBInvRow(self, row): # <<<<<<<<<<<<<< + * """gets a row from the inverse basis matrix B^-1""" + * # TODO: sparsity information + */ + __pyx_tuple__745 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_row, __pyx_n_s_nrows, __pyx_n_s_coefs, __pyx_n_s_result, __pyx_n_s_i); if (unlikely(!__pyx_tuple__745)) __PYX_ERR(0, 1934, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__745); + __Pyx_GIVEREF(__pyx_tuple__745); + __pyx_codeobj__746 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__745, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPBInvRow, 1934, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__746)) __PYX_ERR(0, 1934, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1945 + * return result + * + * def getLPBInvARow(self, row): # <<<<<<<<<<<<<< + * """gets a row from B^-1 * A""" + * # TODO: sparsity information + */ + __pyx_tuple__747 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_row, __pyx_n_s_ncols, __pyx_n_s_coefs, __pyx_n_s_result, __pyx_n_s_i); if (unlikely(!__pyx_tuple__747)) __PYX_ERR(0, 1945, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__747); + __Pyx_GIVEREF(__pyx_tuple__747); + __pyx_codeobj__748 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__747, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPBInvARow, 1945, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__748)) __PYX_ERR(0, 1945, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1956 + * return result + * + * def isLPSolBasic(self): # <<<<<<<<<<<<<< + * """returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis""" + * return SCIPisLPSolBasic(self._scip) + */ + __pyx_codeobj__749 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isLPSolBasic, 1956, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__749)) __PYX_ERR(0, 1956, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1962 + * #TODO: documentation!! + * # LP Row Methods + * def createEmptyRowSepa(self, Sepa sepa, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True): # <<<<<<<<<<<<<< + * """creates and captures an LP row without any coefficients from a separator + * + */ + __pyx_tuple__750 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_sepa, __pyx_n_s_name, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_removable, __pyx_n_s_row, __pyx_n_s_scip_sepa, __pyx_n_s_PyRow); if (unlikely(!__pyx_tuple__750)) __PYX_ERR(0, 1962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__750); + __Pyx_GIVEREF(__pyx_tuple__750); + __pyx_codeobj__751 = (PyObject*)__Pyx_PyCode_New(8, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__750, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createEmptyRowSepa, 1962, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__751)) __PYX_ERR(0, 1962, __pyx_L1_error) + __pyx_tuple__752 = PyTuple_Pack(6, __pyx_n_u_row, __pyx_float_0_0, Py_None, Py_True, Py_False, Py_True); if (unlikely(!__pyx_tuple__752)) __PYX_ERR(0, 1962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__752); + __Pyx_GIVEREF(__pyx_tuple__752); + + /* "src/pyscipopt/scip.pxi":1981 + * return PyRow + * + * def createEmptyRowUnspec(self, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True): # <<<<<<<<<<<<<< + * """creates and captures an LP row without any coefficients from an unspecified source + * + */ + __pyx_tuple__753 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_removable, __pyx_n_s_row, __pyx_n_s_PyRow); if (unlikely(!__pyx_tuple__753)) __PYX_ERR(0, 1981, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__753); + __Pyx_GIVEREF(__pyx_tuple__753); + __pyx_codeobj__754 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__753, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createEmptyRowUnspec, 1981, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__754)) __PYX_ERR(0, 1981, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":1998 + * return PyRow + * + * def getRowActivity(self, Row row): # <<<<<<<<<<<<<< + * """returns the activity of a row in the last LP or pseudo solution""" + * return SCIPgetRowActivity(self._scip, row.scip_row) + */ + __pyx_codeobj__755 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRowActivity, 1998, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__755)) __PYX_ERR(0, 1998, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2002 + * return SCIPgetRowActivity(self._scip, row.scip_row) + * + * def getRowLPActivity(self, Row row): # <<<<<<<<<<<<<< + * """returns the activity of a row in the last LP solution""" + * return SCIPgetRowLPActivity(self._scip, row.scip_row) + */ + __pyx_codeobj__756 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRowLPActivity, 2002, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__756)) __PYX_ERR(0, 2002, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2007 + * + * # TODO: do we need this? (also do we need release var??) + * def releaseRow(self, Row row not None): # <<<<<<<<<<<<<< + * """decreases usage counter of LP row, and frees memory if necessary""" + * PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row)) + */ + __pyx_codeobj__757 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_releaseRow, 2007, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__757)) __PYX_ERR(0, 2007, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2011 + * PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row)) + * + * def cacheRowExtensions(self, Row row not None): # <<<<<<<<<<<<<< + * """informs row, that all subsequent additions of variables to the row should be cached and not directly applied; + * after all additions were applied, flushRowExtensions() must be called; + */ + __pyx_codeobj__758 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_cacheRowExtensions, 2011, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__758)) __PYX_ERR(0, 2011, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2018 + * PY_SCIP_CALL(SCIPcacheRowExtensions(self._scip, row.scip_row)) + * + * def flushRowExtensions(self, Row row not None): # <<<<<<<<<<<<<< + * """flushes all cached row extensions after a call of cacheRowExtensions() and merges coefficients with equal columns into a single coefficient""" + * PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row)) + */ + __pyx_codeobj__759 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_flushRowExtensions, 2018, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__759)) __PYX_ERR(0, 2018, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2022 + * PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row)) + * + * def addVarToRow(self, Row row not None, Variable var not None, value): # <<<<<<<<<<<<<< + * """resolves variable to columns and adds them with the coefficient to the row""" + * PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value)) + */ + __pyx_tuple__760 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_row, __pyx_n_s_var, __pyx_n_s_value); if (unlikely(!__pyx_tuple__760)) __PYX_ERR(0, 2022, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__760); + __Pyx_GIVEREF(__pyx_tuple__760); + __pyx_codeobj__761 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__760, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addVarToRow, 2022, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__761)) __PYX_ERR(0, 2022, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2026 + * PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value)) + * + * def printRow(self, Row row not None): # <<<<<<<<<<<<<< + * """Prints row.""" + * PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL)) + */ + __pyx_codeobj__762 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_printRow, 2026, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__762)) __PYX_ERR(0, 2026, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2030 + * PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL)) + * + * def getRowNumIntCols(self, Row row): # <<<<<<<<<<<<<< + * """Returns number of intergal columns in the row""" + * return SCIPgetRowNumIntCols(self._scip, row.scip_row) + */ + __pyx_codeobj__763 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRowNumIntCols, 2030, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__763)) __PYX_ERR(0, 2030, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2034 + * return SCIPgetRowNumIntCols(self._scip, row.scip_row) + * + * def getRowObjParallelism(self, Row row): # <<<<<<<<<<<<<< + * """Returns 1 if the row is parallel, and 0 if orthogonal""" + * return SCIPgetRowObjParallelism(self._scip, row.scip_row) + */ + __pyx_codeobj__764 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRowObjParallelism, 2034, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__764)) __PYX_ERR(0, 2034, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2038 + * return SCIPgetRowObjParallelism(self._scip, row.scip_row) + * + * def getRowParallelism(self, Row row1, Row row2, orthofunc=101): # <<<<<<<<<<<<<< + * """Returns the degree of parallelism between hyplerplanes. 1 if perfectly parallel, 0 if orthognal. + * 101 in this case is an 'e' (euclidean) in ASCII. The other accpetable input is 100 (d for discrete).""" + */ + __pyx_tuple__765 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_row1, __pyx_n_s_row2, __pyx_n_s_orthofunc); if (unlikely(!__pyx_tuple__765)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__765); + __Pyx_GIVEREF(__pyx_tuple__765); + __pyx_codeobj__766 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__765, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRowParallelism, 2038, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__766)) __PYX_ERR(0, 2038, __pyx_L1_error) + __pyx_tuple__767 = PyTuple_Pack(1, __pyx_int_101); if (unlikely(!__pyx_tuple__767)) __PYX_ERR(0, 2038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__767); + __Pyx_GIVEREF(__pyx_tuple__767); + + /* "src/pyscipopt/scip.pxi":2043 + * return SCIProwGetParallelism(row1.scip_row, row2.scip_row, orthofunc) + * + * def getRowDualSol(self, Row row): # <<<<<<<<<<<<<< + * """Gets the dual LP solution of a row""" + * return SCIProwGetDualsol(row.scip_row) + */ + __pyx_codeobj__768 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRowDualSol, 2043, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__768)) __PYX_ERR(0, 2043, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2048 + * + * # Cutting Plane Methods + * def addPoolCut(self, Row row not None): # <<<<<<<<<<<<<< + * """if not already existing, adds row to global cut pool""" + * PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row)) + */ + __pyx_codeobj__769 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addPoolCut, 2048, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__769)) __PYX_ERR(0, 2048, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2052 + * PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row)) + * + * def getCutEfficacy(self, Row cut not None, Solution sol = None): # <<<<<<<<<<<<<< + * """returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm""" + * return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + */ + __pyx_tuple__770 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cut, __pyx_n_s_sol); if (unlikely(!__pyx_tuple__770)) __PYX_ERR(0, 2052, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__770); + __Pyx_GIVEREF(__pyx_tuple__770); + __pyx_codeobj__771 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__770, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getCutEfficacy, 2052, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__771)) __PYX_ERR(0, 2052, __pyx_L1_error) + __pyx_tuple__772 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__772)) __PYX_ERR(0, 2052, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__772); + __Pyx_GIVEREF(__pyx_tuple__772); + + /* "src/pyscipopt/scip.pxi":2056 + * return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + * + * def isCutEfficacious(self, Row cut not None, Solution sol = None): # <<<<<<<<<<<<<< + * """ returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy""" + * return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + */ + __pyx_codeobj__773 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__770, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isCutEfficacious, 2056, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__773)) __PYX_ERR(0, 2056, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2060 + * return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row) + * + * def getCutLPSolCutoffDistance(self, Row cut not None, Solution sol not None): # <<<<<<<<<<<<<< + * """ returns row's cutoff distance in the direction of the given primal solution""" + * return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row) + */ + __pyx_codeobj__774 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__770, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getCutLPSolCutoffDistance, 2060, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__774)) __PYX_ERR(0, 2060, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2064 + * return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row) + * + * def addCut(self, Row cut not None, forcecut = False): # <<<<<<<<<<<<<< + * """adds cut to separation storage and returns whether cut has been detected to be infeasible for local bounds""" + * cdef SCIP_Bool infeasible + */ + __pyx_tuple__775 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cut, __pyx_n_s_forcecut, __pyx_n_s_infeasible); if (unlikely(!__pyx_tuple__775)) __PYX_ERR(0, 2064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__775); + __Pyx_GIVEREF(__pyx_tuple__775); + __pyx_codeobj__776 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__775, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addCut, 2064, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__776)) __PYX_ERR(0, 2064, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2070 + * return infeasible + * + * def getNCuts(self): # <<<<<<<<<<<<<< + * """Retrieve total number of cuts in storage""" + * return SCIPgetNCuts(self._scip) + */ + __pyx_codeobj__777 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNCuts, 2070, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__777)) __PYX_ERR(0, 2070, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2074 + * return SCIPgetNCuts(self._scip) + * + * def getNCutsApplied(self): # <<<<<<<<<<<<<< + * """Retrieve number of currently applied cuts""" + * return SCIPgetNCutsApplied(self._scip) + */ + __pyx_codeobj__778 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNCutsApplied, 2074, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__778)) __PYX_ERR(0, 2074, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2078 + * return SCIPgetNCutsApplied(self._scip) + * + * def getNSepaRounds(self): # <<<<<<<<<<<<<< + * """Retrieve the number of separation rounds that have been performed + * at the current node""" + */ + __pyx_codeobj__779 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNSepaRounds, 2078, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__779)) __PYX_ERR(0, 2078, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2083 + * return SCIPgetNSepaRounds(self._scip) + * + * def separateSol(self, Solution sol = None, pretendroot = False, allowlocal = True, onlydelayed = False): # <<<<<<<<<<<<<< + * """separates the given primal solution or the current LP solution by calling the separators and constraint handlers' + * separation methods; + */ + __pyx_tuple__780 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_sol, __pyx_n_s_pretendroot, __pyx_n_s_allowlocal, __pyx_n_s_onlydelayed, __pyx_n_s_delayed, __pyx_n_s_cutoff); if (unlikely(!__pyx_tuple__780)) __PYX_ERR(0, 2083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__780); + __Pyx_GIVEREF(__pyx_tuple__780); + __pyx_codeobj__781 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__780, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_separateSol, 2083, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__781)) __PYX_ERR(0, 2083, __pyx_L1_error) + __pyx_tuple__782 = PyTuple_Pack(4, Py_None, Py_False, Py_True, Py_False); if (unlikely(!__pyx_tuple__782)) __PYX_ERR(0, 2083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__782); + __Pyx_GIVEREF(__pyx_tuple__782); + + /* "src/pyscipopt/scip.pxi":2106 + * return delayed, cutoff + * + * def _createConsLinear(self, ExprCons lincons, **kwargs): # <<<<<<<<<<<<<< + * assert isinstance(lincons, ExprCons), "given constraint is not ExprCons but %s" % lincons.__class__.__name__ + * + */ + __pyx_tuple__783 = PyTuple_Pack(12, __pyx_n_s_self, __pyx_n_s_lincons, __pyx_n_s_kwargs, __pyx_n_s_terms, __pyx_n_s_scip_cons, __pyx_n_s_nvars, __pyx_n_s_vars_array, __pyx_n_s_coeffs_array, __pyx_n_s_i, __pyx_n_s_key, __pyx_n_s_coeff, __pyx_n_s_PyCons); if (unlikely(!__pyx_tuple__783)) __PYX_ERR(0, 2106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__783); + __Pyx_GIVEREF(__pyx_tuple__783); + __pyx_codeobj__784 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__783, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createConsLinear, 2106, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__784)) __PYX_ERR(0, 2106, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2136 + * return PyCons + * + * def _createConsQuadratic(self, ExprCons quadcons, **kwargs): # <<<<<<<<<<<<<< + * terms = quadcons.expr.terms + * assert quadcons.expr.degree() <= 2, "given constraint is not quadratic, degree == %d" % quadcons.expr.degree() + */ + __pyx_tuple__785 = PyTuple_Pack(13, __pyx_n_s_self, __pyx_n_s_quadcons, __pyx_n_s_kwargs, __pyx_n_s_terms, __pyx_n_s_scip_cons, __pyx_n_s_prodexpr, __pyx_n_s_v, __pyx_n_s_c, __pyx_n_s_var, __pyx_n_s_varexprs, __pyx_n_s_var1, __pyx_n_s_var2, __pyx_n_s_PyCons); if (unlikely(!__pyx_tuple__785)) __PYX_ERR(0, 2136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__785); + __Pyx_GIVEREF(__pyx_tuple__785); + __pyx_codeobj__786 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__785, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createConsQuadratic, 2136, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__786)) __PYX_ERR(0, 2136, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2175 + * return PyCons + * + * def _createConsNonlinear(self, cons, **kwargs): # <<<<<<<<<<<<<< + * cdef SCIP_EXPR* expr + * cdef SCIP_EXPR** varexprs + */ + __pyx_tuple__787 = PyTuple_Pack(23, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_kwargs, __pyx_n_s_expr, __pyx_n_s_varexprs, __pyx_n_s_monomials, __pyx_n_s_idxs, __pyx_n_s_scip_cons, __pyx_n_s_terms, __pyx_n_s_variables, __pyx_n_s_varindex, __pyx_n_s_termcoefs, __pyx_n_s_i, __pyx_n_s_term, __pyx_n_s_coef, __pyx_n_s_termvars, __pyx_n_s_j, __pyx_n_s_var, __pyx_n_s_PyCons, __pyx_n_s_term, __pyx_n_s_var, __pyx_n_s_idx, __pyx_n_s_var); if (unlikely(!__pyx_tuple__787)) __PYX_ERR(0, 2175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__787); + __Pyx_GIVEREF(__pyx_tuple__787); + __pyx_codeobj__788 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 23, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__787, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createConsNonlinear, 2175, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__788)) __PYX_ERR(0, 2175, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2230 + * return PyCons + * + * def _createConsGenNonlinear(self, cons, **kwargs): # <<<<<<<<<<<<<< + * cdef SCIP_EXPR** childrenexpr + * cdef SCIP_EXPR** scipexprs + */ + __pyx_tuple__789 = PyTuple_Pack(23, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_kwargs, __pyx_n_s_childrenexpr, __pyx_n_s_scipexprs, __pyx_n_s_scip_cons, __pyx_n_s_nchildren, __pyx_n_s_expr, __pyx_n_s_nodes, __pyx_n_s_nvars, __pyx_n_s_node, __pyx_n_s_vars, __pyx_n_s_varpos, __pyx_n_s_i, __pyx_n_s_opidx, __pyx_n_s_pyvar, __pyx_n_s_value, __pyx_n_s_coefs, __pyx_n_s_c, __pyx_n_s_pos, __pyx_n_s_valuenode, __pyx_n_s_exponent, __pyx_n_s_PyCons); if (unlikely(!__pyx_tuple__789)) __PYX_ERR(0, 2230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__789); + __Pyx_GIVEREF(__pyx_tuple__789); + __pyx_codeobj__790 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 23, 0, CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__789, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createConsGenNonlinear, 2230, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__790)) __PYX_ERR(0, 2230, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2351 + * return PyCons + * + * def createConsFromExpr(self, cons, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + __pyx_tuple__791 = PyTuple_Pack(15, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_kwargs, __pyx_n_s_deg); if (unlikely(!__pyx_tuple__791)) __PYX_ERR(0, 2351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__791); + __Pyx_GIVEREF(__pyx_tuple__791); + __pyx_codeobj__792 = (PyObject*)__Pyx_PyCode_New(13, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__791, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createConsFromExpr, 2351, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__792)) __PYX_ERR(0, 2351, __pyx_L1_error) + __pyx_tuple__793 = PyTuple_Pack(11, __pyx_kp_u__89, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__793)) __PYX_ERR(0, 2351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__793); + __Pyx_GIVEREF(__pyx_tuple__793); + + /* "src/pyscipopt/scip.pxi":2397 + * + * # Constraint functions + * def addCons(self, cons, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + __pyx_tuple__794 = PyTuple_Pack(17, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_scip_cons, __pyx_n_s_kwargs, __pyx_n_s_pycons_initial, __pyx_n_s_pycons); if (unlikely(!__pyx_tuple__794)) __PYX_ERR(0, 2397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__794); + __Pyx_GIVEREF(__pyx_tuple__794); + __pyx_codeobj__795 = (PyObject*)__Pyx_PyCode_New(13, 0, 0, 17, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__794, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addCons, 2397, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__795)) __PYX_ERR(0, 2397, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2441 + * return pycons + * + * def addConss(self, conss, name='', initial=True, separate=True, # <<<<<<<<<<<<<< + * enforce=True, check=True, propagate=True, local=False, + * modifiable=False, dynamic=False, removable=False, + */ + __pyx_tuple__796 = PyTuple_Pack(21, __pyx_n_s_self, __pyx_n_s_conss, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_ensure_iterable, __pyx_n_s_ensure_iterable, __pyx_n_s_n_conss, __pyx_n_s_constraints, __pyx_n_s_i, __pyx_n_s_cons, __pyx_n_s_idx, __pyx_n_s_idx); if (unlikely(!__pyx_tuple__796)) __PYX_ERR(0, 2441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__796); + __Pyx_GIVEREF(__pyx_tuple__796); + __pyx_codeobj__797 = (PyObject*)__Pyx_PyCode_New(13, 0, 0, 21, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__796, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConss, 2441, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__797)) __PYX_ERR(0, 2441, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2506 + * return constraints + * + * def addConsDisjunction(self, conss, name = '', initial = True, # <<<<<<<<<<<<<< + * relaxcons = None, enforce=True, check =True, + * local=False, modifiable = False, dynamic = False): + */ + __pyx_tuple__798 = PyTuple_Pack(20, __pyx_n_s_self, __pyx_n_s_conss, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_relaxcons, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_dynamic, __pyx_n_s_ensure_iterable, __pyx_n_s_ensure_iterable, __pyx_n_s_n_conss, __pyx_n_s_disj_cons, __pyx_n_s_scip_cons, __pyx_n_s_scip_expr, __pyx_n_s_i, __pyx_n_s_cons, __pyx_n_s_pycons, __pyx_n_s_PyCons); if (unlikely(!__pyx_tuple__798)) __PYX_ERR(0, 2506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__798); + __Pyx_GIVEREF(__pyx_tuple__798); + __pyx_codeobj__799 = (PyObject*)__Pyx_PyCode_New(10, 0, 0, 20, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__798, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsDisjunction, 2506, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__799)) __PYX_ERR(0, 2506, __pyx_L1_error) + __pyx_tuple__800 = PyTuple_Pack(8, __pyx_kp_u__89, Py_True, Py_None, Py_True, Py_True, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__800)) __PYX_ERR(0, 2506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__800); + __Pyx_GIVEREF(__pyx_tuple__800); + + /* "src/pyscipopt/scip.pxi":2557 + * return PyCons + * + * def addConsElemDisjunction(self, Constraint disj_cons, Constraint cons): # <<<<<<<<<<<<<< + * """Appends a constraint to a disjunction. + * + */ + __pyx_tuple__801 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_disj_cons, __pyx_n_s_cons); if (unlikely(!__pyx_tuple__801)) __PYX_ERR(0, 2557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__801); + __Pyx_GIVEREF(__pyx_tuple__801); + __pyx_codeobj__802 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__801, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsElemDisjunction, 2557, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__802)) __PYX_ERR(0, 2557, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2568 + * return disj_cons + * + * def getConsNVars(self, Constraint constraint): # <<<<<<<<<<<<<< + * """ + * Gets number of variables in a constraint. + */ + __pyx_tuple__803 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_constraint, __pyx_n_s_nvars, __pyx_n_s_success, __pyx_n_s_conshdlr, __pyx_n_s_conshdrlname); if (unlikely(!__pyx_tuple__803)) __PYX_ERR(0, 2568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__803); + __Pyx_GIVEREF(__pyx_tuple__803); + __pyx_codeobj__804 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__803, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getConsNVars, 2568, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__804)) __PYX_ERR(0, 2568, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2586 + * return nvars + * + * def getConsVars(self, Constraint constraint): # <<<<<<<<<<<<<< + * """ + * Gets variables in a constraint. + */ + __pyx_tuple__805 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_constraint, __pyx_n_s_success, __pyx_n_s_nvars_2, __pyx_n_s_vars_2, __pyx_n_s_vars, __pyx_n_s_i, __pyx_n_s_ptr, __pyx_n_s_var); if (unlikely(!__pyx_tuple__805)) __PYX_ERR(0, 2586, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__805); + __Pyx_GIVEREF(__pyx_tuple__805); + __pyx_codeobj__806 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__805, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getConsVars, 2586, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__806)) __PYX_ERR(0, 2586, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2614 + * return vars + * + * def printCons(self, Constraint constraint): # <<<<<<<<<<<<<< + * return PY_SCIP_CALL(SCIPprintCons(self._scip, constraint.scip_cons, NULL)) + * + */ + __pyx_codeobj__807 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__304, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_printCons, 2614, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__807)) __PYX_ERR(0, 2614, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2619 + * # TODO Find a better way to retrieve a scip expression from a python expression. Consider making GenExpr include Expr, to avoid using Union. See PR #760. + * from typing import Union + * def addExprNonlinear(self, Constraint cons, expr: Union[Expr,GenExpr], float coef): # <<<<<<<<<<<<<< + * """ + * Add coef*expr to nonlinear constraint. + */ + __pyx_tuple__808 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_expr, __pyx_n_s_coef, __pyx_n_s_temp_cons, __pyx_n_s_scip_expr); if (unlikely(!__pyx_tuple__808)) __PYX_ERR(0, 2619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__808); + __Pyx_GIVEREF(__pyx_tuple__808); + __pyx_codeobj__809 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__808, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addExprNonlinear, 2619, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__809)) __PYX_ERR(0, 2619, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2635 + * self.delCons(temp_cons) + * + * def addConsCoeff(self, Constraint cons, Variable var, coeff): # <<<<<<<<<<<<<< + * """Add coefficient to the linear constraint (if non-zero). + * + */ + __pyx_tuple__810 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_var, __pyx_n_s_coeff); if (unlikely(!__pyx_tuple__810)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__810); + __Pyx_GIVEREF(__pyx_tuple__810); + __pyx_codeobj__811 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__810, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsCoeff, 2635, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__811)) __PYX_ERR(0, 2635, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2645 + * PY_SCIP_CALL(SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, coeff)) + * + * def addConsNode(self, Node node, Constraint cons, Node validnode=None): # <<<<<<<<<<<<<< + * """Add a constraint to the given node + * + */ + __pyx_tuple__812 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_node, __pyx_n_s_cons, __pyx_n_s_validnode); if (unlikely(!__pyx_tuple__812)) __PYX_ERR(0, 2645, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__812); + __Pyx_GIVEREF(__pyx_tuple__812); + __pyx_codeobj__813 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__812, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsNode, 2645, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__813)) __PYX_ERR(0, 2645, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2659 + * Py_INCREF(cons) + * + * def addConsLocal(self, Constraint cons, Node validnode=None): # <<<<<<<<<<<<<< + * """Add a constraint to the current node + * + */ + __pyx_tuple__814 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_validnode); if (unlikely(!__pyx_tuple__814)) __PYX_ERR(0, 2659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__814); + __Pyx_GIVEREF(__pyx_tuple__814); + __pyx_codeobj__815 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__814, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsLocal, 2659, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__815)) __PYX_ERR(0, 2659, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2672 + * Py_INCREF(cons) + * + * def addConsSOS1(self, vars, weights=None, name="SOS1cons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + __pyx_tuple__816 = PyTuple_Pack(19, __pyx_n_s_self, __pyx_n_s_vars, __pyx_n_s_weights, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_scip_cons, __pyx_n_s_nvars_2, __pyx_n_s_v, __pyx_n_s_var, __pyx_n_s_nvars, __pyx_n_s_i); if (unlikely(!__pyx_tuple__816)) __PYX_ERR(0, 2672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__816); + __Pyx_GIVEREF(__pyx_tuple__816); + __pyx_codeobj__817 = (PyObject*)__Pyx_PyCode_New(13, 0, 0, 19, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__816, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsSOS1, 2672, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__817)) __PYX_ERR(0, 2672, __pyx_L1_error) + __pyx_tuple__818 = PyTuple_Pack(11, Py_None, __pyx_n_u_SOS1cons, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__818)) __PYX_ERR(0, 2672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__818); + __Pyx_GIVEREF(__pyx_tuple__818); + + /* "src/pyscipopt/scip.pxi":2711 + * return Constraint.create(scip_cons) + * + * def addConsSOS2(self, vars, weights=None, name="SOS2cons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + __pyx_codeobj__819 = (PyObject*)__Pyx_PyCode_New(13, 0, 0, 19, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__816, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsSOS2, 2711, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__819)) __PYX_ERR(0, 2711, __pyx_L1_error) + __pyx_tuple__820 = PyTuple_Pack(11, Py_None, __pyx_n_u_SOS2cons, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__820)) __PYX_ERR(0, 2711, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__820); + __Pyx_GIVEREF(__pyx_tuple__820); + + /* "src/pyscipopt/scip.pxi":2750 + * return Constraint.create(scip_cons) + * + * def addConsAnd(self, vars, resvar, name="ANDcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + __pyx_tuple__821 = PyTuple_Pack(21, __pyx_n_s_self, __pyx_n_s_vars, __pyx_n_s_resvar, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_scip_cons, __pyx_n_s_nvars, __pyx_n_s_vars_2, __pyx_n_s_idx, __pyx_n_s_var, __pyx_n_s_resVar, __pyx_n_s_pyCons); if (unlikely(!__pyx_tuple__821)) __PYX_ERR(0, 2750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__821); + __Pyx_GIVEREF(__pyx_tuple__821); + __pyx_codeobj__822 = (PyObject*)__Pyx_PyCode_New(14, 0, 0, 21, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__821, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsAnd, 2750, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__822)) __PYX_ERR(0, 2750, __pyx_L1_error) + __pyx_tuple__823 = PyTuple_Pack(11, __pyx_n_u_ANDcons, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__823)) __PYX_ERR(0, 2750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__823); + __Pyx_GIVEREF(__pyx_tuple__823); + + /* "src/pyscipopt/scip.pxi":2789 + * return pyCons + * + * def addConsOr(self, vars, resvar, name="ORcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + __pyx_codeobj__824 = (PyObject*)__Pyx_PyCode_New(14, 0, 0, 21, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__821, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsOr, 2789, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__824)) __PYX_ERR(0, 2789, __pyx_L1_error) + __pyx_tuple__825 = PyTuple_Pack(11, __pyx_n_u_ORcons, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__825)) __PYX_ERR(0, 2789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__825); + __Pyx_GIVEREF(__pyx_tuple__825); + + /* "src/pyscipopt/scip.pxi":2828 + * return pyCons + * + * def addConsXor(self, vars, rhsvar, name="XORcons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, modifiable=False, dynamic=False, + */ + __pyx_tuple__826 = PyTuple_Pack(20, __pyx_n_s_self, __pyx_n_s_vars, __pyx_n_s_rhsvar, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_scip_cons, __pyx_n_s_nvars, __pyx_n_s_vars_2, __pyx_n_s_idx, __pyx_n_s_var, __pyx_n_s_pyCons); if (unlikely(!__pyx_tuple__826)) __PYX_ERR(0, 2828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__826); + __Pyx_GIVEREF(__pyx_tuple__826); + __pyx_codeobj__827 = (PyObject*)__Pyx_PyCode_New(14, 0, 0, 20, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__826, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsXor, 2828, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__827)) __PYX_ERR(0, 2828, __pyx_L1_error) + __pyx_tuple__828 = PyTuple_Pack(11, __pyx_n_u_XORcons, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__828)) __PYX_ERR(0, 2828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__828); + __Pyx_GIVEREF(__pyx_tuple__828); + + /* "src/pyscipopt/scip.pxi":2867 + * return pyCons + * + * def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + __pyx_tuple__829 = PyTuple_Pack(21, __pyx_n_s_self, __pyx_n_s_consvars, __pyx_n_s_cardval, __pyx_n_s_indvars, __pyx_n_s_weights, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_scip_cons, __pyx_n_s_indvar, __pyx_n_s_i, __pyx_n_s_v, __pyx_n_s_var, __pyx_n_s_pyCons); if (unlikely(!__pyx_tuple__829)) __PYX_ERR(0, 2867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__829); + __Pyx_GIVEREF(__pyx_tuple__829); + __pyx_codeobj__830 = (PyObject*)__Pyx_PyCode_New(15, 0, 0, 21, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__829, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsCardinality, 2867, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__830)) __PYX_ERR(0, 2867, __pyx_L1_error) + __pyx_tuple__831 = PyTuple_Pack(12, Py_None, Py_None, __pyx_n_u_CardinalityCons, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__831)) __PYX_ERR(0, 2867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__831); + __Pyx_GIVEREF(__pyx_tuple__831); + + /* "src/pyscipopt/scip.pxi":2917 + * return pyCons + * + * def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons", # <<<<<<<<<<<<<< + * initial=True, separate=True, enforce=True, check=True, + * propagate=True, local=False, dynamic=False, + */ + __pyx_tuple__832 = PyTuple_Pack(23, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_binvar, __pyx_n_s_activeone, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_scip_cons, __pyx_n_s_binVar, __pyx_n_s_rhs, __pyx_n_s_negate, __pyx_n_s_terms, __pyx_n_s_key, __pyx_n_s_coeff, __pyx_n_s_var, __pyx_n_s_pyCons); if (unlikely(!__pyx_tuple__832)) __PYX_ERR(0, 2917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__832); + __Pyx_GIVEREF(__pyx_tuple__832); + __pyx_codeobj__833 = (PyObject*)__Pyx_PyCode_New(14, 0, 0, 23, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__832, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addConsIndicator, 2917, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__833)) __PYX_ERR(0, 2917, __pyx_L1_error) + __pyx_tuple__834 = PyTuple_Pack(12, Py_None, Py_True, __pyx_n_u_IndicatorCons, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__834)) __PYX_ERR(0, 2917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__834); + __Pyx_GIVEREF(__pyx_tuple__834); + + /* "src/pyscipopt/scip.pxi":2981 + * return pyCons + * + * def getSlackVarIndicator(self, Constraint cons): # <<<<<<<<<<<<<< + * """Get slack variable of an indicator constraint. + * + */ + __pyx_tuple__835 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_var); if (unlikely(!__pyx_tuple__835)) __PYX_ERR(0, 2981, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__835); + __Pyx_GIVEREF(__pyx_tuple__835); + __pyx_codeobj__836 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__835, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getSlackVarIndicator, 2981, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__836)) __PYX_ERR(0, 2981, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2990 + * return Variable.create(var) + * + * def addPyCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Adds a customly created cons. + * + */ + __pyx_tuple__837 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_cons); if (unlikely(!__pyx_tuple__837)) __PYX_ERR(0, 2990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__837); + __Pyx_GIVEREF(__pyx_tuple__837); + __pyx_codeobj__838 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__837, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addPyCons, 2990, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__838)) __PYX_ERR(0, 2990, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":2999 + * Py_INCREF(cons) + * + * def addVarSOS1(self, Constraint cons, Variable var, weight): # <<<<<<<<<<<<<< + * """Add variable to SOS1 constraint. + * + */ + __pyx_tuple__839 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_var, __pyx_n_s_weight); if (unlikely(!__pyx_tuple__839)) __PYX_ERR(0, 2999, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__839); + __Pyx_GIVEREF(__pyx_tuple__839); + __pyx_codeobj__840 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__839, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addVarSOS1, 2999, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__840)) __PYX_ERR(0, 2999, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3009 + * PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, cons.scip_cons, var.scip_var, weight)) + * + * def appendVarSOS1(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Append variable to SOS1 constraint. + * + */ + __pyx_codeobj__841 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__835, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_appendVarSOS1, 3009, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__841)) __PYX_ERR(0, 3009, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3018 + * PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, cons.scip_cons, var.scip_var)) + * + * def addVarSOS2(self, Constraint cons, Variable var, weight): # <<<<<<<<<<<<<< + * """Add variable to SOS2 constraint. + * + */ + __pyx_codeobj__842 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__839, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addVarSOS2, 3018, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__842)) __PYX_ERR(0, 3018, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3028 + * PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, cons.scip_cons, var.scip_var, weight)) + * + * def appendVarSOS2(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Append variable to SOS2 constraint. + * + */ + __pyx_codeobj__843 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__835, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_appendVarSOS2, 3028, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__843)) __PYX_ERR(0, 3028, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3037 + * PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, cons.scip_cons, var.scip_var)) + * + * def setInitial(self, Constraint cons, newInit): # <<<<<<<<<<<<<< + * """Set "initial" flag of a constraint. + * + */ + __pyx_tuple__844 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_newInit); if (unlikely(!__pyx_tuple__844)) __PYX_ERR(0, 3037, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__844); + __Pyx_GIVEREF(__pyx_tuple__844); + __pyx_codeobj__845 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__844, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setInitial, 3037, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__845)) __PYX_ERR(0, 3037, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3046 + * PY_SCIP_CALL(SCIPsetConsInitial(self._scip, cons.scip_cons, newInit)) + * + * def setRemovable(self, Constraint cons, newRem): # <<<<<<<<<<<<<< + * """Set "removable" flag of a constraint. + * + */ + __pyx_tuple__846 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_newRem); if (unlikely(!__pyx_tuple__846)) __PYX_ERR(0, 3046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__846); + __Pyx_GIVEREF(__pyx_tuple__846); + __pyx_codeobj__847 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__846, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setRemovable, 3046, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__847)) __PYX_ERR(0, 3046, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3055 + * PY_SCIP_CALL(SCIPsetConsRemovable(self._scip, cons.scip_cons, newRem)) + * + * def setEnforced(self, Constraint cons, newEnf): # <<<<<<<<<<<<<< + * """Set "enforced" flag of a constraint. + * + */ + __pyx_tuple__848 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_newEnf); if (unlikely(!__pyx_tuple__848)) __PYX_ERR(0, 3055, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__848); + __Pyx_GIVEREF(__pyx_tuple__848); + __pyx_codeobj__849 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__848, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setEnforced, 3055, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__849)) __PYX_ERR(0, 3055, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3064 + * PY_SCIP_CALL(SCIPsetConsEnforced(self._scip, cons.scip_cons, newEnf)) + * + * def setCheck(self, Constraint cons, newCheck): # <<<<<<<<<<<<<< + * """Set "check" flag of a constraint. + * + */ + __pyx_tuple__850 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_newCheck); if (unlikely(!__pyx_tuple__850)) __PYX_ERR(0, 3064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__850); + __Pyx_GIVEREF(__pyx_tuple__850); + __pyx_codeobj__851 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__850, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setCheck, 3064, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__851)) __PYX_ERR(0, 3064, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3073 + * PY_SCIP_CALL(SCIPsetConsChecked(self._scip, cons.scip_cons, newCheck)) + * + * def chgRhs(self, Constraint cons, rhs): # <<<<<<<<<<<<<< + * """Change right hand side value of a constraint. + * + */ + __pyx_tuple__852 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_rhs, __pyx_n_s_constype); if (unlikely(!__pyx_tuple__852)) __PYX_ERR(0, 3073, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__852); + __Pyx_GIVEREF(__pyx_tuple__852); + __pyx_codeobj__853 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__852, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgRhs, 3073, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__853)) __PYX_ERR(0, 3073, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3092 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def chgLhs(self, Constraint cons, lhs): # <<<<<<<<<<<<<< + * """Change left hand side value of a constraint. + * + */ + __pyx_tuple__854 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_lhs, __pyx_n_s_constype); if (unlikely(!__pyx_tuple__854)) __PYX_ERR(0, 3092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__854); + __Pyx_GIVEREF(__pyx_tuple__854); + __pyx_codeobj__855 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__854, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgLhs, 3092, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__855)) __PYX_ERR(0, 3092, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3111 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def getRhs(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve right hand side value of a constraint. + * + */ + __pyx_tuple__856 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_constype); if (unlikely(!__pyx_tuple__856)) __PYX_ERR(0, 3111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__856); + __Pyx_GIVEREF(__pyx_tuple__856); + __pyx_codeobj__857 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__856, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRhs, 3111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__857)) __PYX_ERR(0, 3111, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3125 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def getLhs(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve left hand side value of a constraint. + * + */ + __pyx_codeobj__858 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__856, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLhs, 3125, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__858)) __PYX_ERR(0, 3125, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3139 + * raise Warning("method cannot be called for constraints of type " + constype) + * + * def chgCoefLinear(self, Constraint cons, Variable var, value): # <<<<<<<<<<<<<< + * """Changes coefficient of variable in linear constraint; + * deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint + */ + __pyx_tuple__859 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_var, __pyx_n_s_value); if (unlikely(!__pyx_tuple__859)) __PYX_ERR(0, 3139, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__859); + __Pyx_GIVEREF(__pyx_tuple__859); + __pyx_codeobj__860 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__859, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgCoefLinear, 3139, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__860)) __PYX_ERR(0, 3139, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3152 + * PY_SCIP_CALL( SCIPchgCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) ) + * + * def delCoefLinear(self, Constraint cons, Variable var): # <<<<<<<<<<<<<< + * """Deletes variable from linear constraint + * This method may only be called during problem creation stage for an original constraint and variable. + */ + __pyx_codeobj__861 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__835, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_delCoefLinear, 3152, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__861)) __PYX_ERR(0, 3152, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3164 + * PY_SCIP_CALL( SCIPdelCoefLinear(self._scip, cons.scip_cons, var.scip_var) ) + * + * def addCoefLinear(self, Constraint cons, Variable var, value): # <<<<<<<<<<<<<< + * """Adds coefficient to linear constraint (if it is not zero) + * + */ + __pyx_codeobj__862 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__859, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addCoefLinear, 3164, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__862)) __PYX_ERR(0, 3164, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3175 + * PY_SCIP_CALL( SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) ) + * + * def getActivity(self, Constraint cons, Solution sol = None): # <<<<<<<<<<<<<< + * """Retrieve activity of given constraint. + * Can only be called after solving is completed. + */ + __pyx_tuple__863 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_sol, __pyx_n_s_activity, __pyx_n_s_scip_sol, __pyx_n_s_constype); if (unlikely(!__pyx_tuple__863)) __PYX_ERR(0, 3175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__863); + __Pyx_GIVEREF(__pyx_tuple__863); + __pyx_codeobj__864 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__863, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getActivity, 3175, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__864)) __PYX_ERR(0, 3175, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3203 + * + * + * def getSlack(self, Constraint cons, Solution sol = None, side = None): # <<<<<<<<<<<<<< + * """Retrieve slack of given constraint. + * Can only be called after solving is completed. + */ + __pyx_tuple__865 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_sol, __pyx_n_s_side, __pyx_n_s_activity, __pyx_n_s_scip_sol, __pyx_n_s_constype, __pyx_n_s_lhs, __pyx_n_s_rhs, __pyx_n_s_lhsslack, __pyx_n_s_rhsslack); if (unlikely(!__pyx_tuple__865)) __PYX_ERR(0, 3203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__865); + __Pyx_GIVEREF(__pyx_tuple__865); + __pyx_codeobj__866 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__865, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getSlack, 3203, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__866)) __PYX_ERR(0, 3203, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3243 + * return min(lhsslack, rhsslack) + * + * def getTransformedCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve transformed constraint. + * + */ + __pyx_tuple__867 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_transcons); if (unlikely(!__pyx_tuple__867)) __PYX_ERR(0, 3243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__867); + __Pyx_GIVEREF(__pyx_tuple__867); + __pyx_codeobj__868 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__867, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getTransformedCons, 3243, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__868)) __PYX_ERR(0, 3243, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3253 + * return Constraint.create(transcons) + * + * def isNLPConstructed(self): # <<<<<<<<<<<<<< + * """returns whether SCIP's internal NLP has been constructed""" + * return SCIPisNLPConstructed(self._scip) + */ + __pyx_codeobj__869 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isNLPConstructed, 3253, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__869)) __PYX_ERR(0, 3253, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3257 + * return SCIPisNLPConstructed(self._scip) + * + * def getNNlRows(self): # <<<<<<<<<<<<<< + * """gets current number of nonlinear rows in SCIP's internal NLP""" + * return SCIPgetNNLPNlRows(self._scip) + */ + __pyx_codeobj__870 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNNlRows, 3257, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__870)) __PYX_ERR(0, 3257, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3261 + * return SCIPgetNNLPNlRows(self._scip) + * + * def getNlRows(self): # <<<<<<<<<<<<<< + * """returns a list with the nonlinear rows in SCIP's internal NLP""" + * cdef SCIP_NLROW** nlrows + */ + __pyx_tuple__871 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_nlrows, __pyx_n_s_i); if (unlikely(!__pyx_tuple__871)) __PYX_ERR(0, 3261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__871); + __Pyx_GIVEREF(__pyx_tuple__871); + __pyx_codeobj__872 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__871, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNlRows, 3261, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__872)) __PYX_ERR(0, 3261, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3268 + * return [NLRow.create(nlrows[i]) for i in range(self.getNNlRows())] + * + * def getNlRowSolActivity(self, NLRow nlrow, Solution sol = None): # <<<<<<<<<<<<<< + * """gives the activity of a nonlinear row for a given primal solution + * Keyword arguments: + */ + __pyx_tuple__873 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_nlrow, __pyx_n_s_sol, __pyx_n_s_activity, __pyx_n_s_solptr); if (unlikely(!__pyx_tuple__873)) __PYX_ERR(0, 3268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__873); + __Pyx_GIVEREF(__pyx_tuple__873); + __pyx_codeobj__874 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__873, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNlRowSolActivity, 3268, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__874)) __PYX_ERR(0, 3268, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3281 + * return activity + * + * def getNlRowSolFeasibility(self, NLRow nlrow, Solution sol = None): # <<<<<<<<<<<<<< + * """gives the feasibility of a nonlinear row for a given primal solution + * Keyword arguments: + */ + __pyx_tuple__875 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_nlrow, __pyx_n_s_sol, __pyx_n_s_feasibility, __pyx_n_s_solptr); if (unlikely(!__pyx_tuple__875)) __PYX_ERR(0, 3281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__875); + __Pyx_GIVEREF(__pyx_tuple__875); + __pyx_codeobj__876 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__875, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNlRowSolFeasibility, 3281, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__876)) __PYX_ERR(0, 3281, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3294 + * return feasibility + * + * def getNlRowActivityBounds(self, NLRow nlrow): # <<<<<<<<<<<<<< + * """gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds""" + * cdef SCIP_Real minactivity + */ + __pyx_tuple__877 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_nlrow, __pyx_n_s_minactivity, __pyx_n_s_maxactivity); if (unlikely(!__pyx_tuple__877)) __PYX_ERR(0, 3294, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__877); + __Pyx_GIVEREF(__pyx_tuple__877); + __pyx_codeobj__878 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__877, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNlRowActivityBounds, 3294, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__878)) __PYX_ERR(0, 3294, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3302 + * return (minactivity, maxactivity) + * + * def printNlRow(self, NLRow nlrow): # <<<<<<<<<<<<<< + * """prints nonlinear row""" + * PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) ) + */ + __pyx_tuple__879 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_nlrow); if (unlikely(!__pyx_tuple__879)) __PYX_ERR(0, 3302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__879); + __Pyx_GIVEREF(__pyx_tuple__879); + __pyx_codeobj__880 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__879, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_printNlRow, 3302, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__880)) __PYX_ERR(0, 3302, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3306 + * PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) ) + * + * def checkQuadraticNonlinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """returns if the given constraint is quadratic + * + */ + __pyx_tuple__881 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_isquadratic); if (unlikely(!__pyx_tuple__881)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__881); + __Pyx_GIVEREF(__pyx_tuple__881); + __pyx_codeobj__882 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__881, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_checkQuadraticNonlinear, 3306, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__882)) __PYX_ERR(0, 3306, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3316 + * return isquadratic + * + * def getTermsQuadratic(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve bilinear, quadratic, and linear terms of a quadratic constraint. + * + */ + __pyx_tuple__883 = PyTuple_Pack(23, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_expr, __pyx_n_s_linexprs, __pyx_n_s_lincoefs_2, __pyx_n_s_nlinvars_2, __pyx_n_s_nbilinterms, __pyx_n_s_bilinterm1, __pyx_n_s_bilinterm2, __pyx_n_s_bilincoef, __pyx_n_s_nquadterms, __pyx_n_s_sqrcoef, __pyx_n_s_lincoef, __pyx_n_s_sqrexpr, __pyx_n_s_scipvar1, __pyx_n_s_scipvar2, __pyx_n_s_linterms, __pyx_n_s_bilinterms, __pyx_n_s_quadterms, __pyx_n_s_termidx, __pyx_n_s_var, __pyx_n_s_var1, __pyx_n_s_var2); if (unlikely(!__pyx_tuple__883)) __PYX_ERR(0, 3316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__883); + __Pyx_GIVEREF(__pyx_tuple__883); + __pyx_codeobj__884 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 23, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__883, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getTermsQuadratic, 3316, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__884)) __PYX_ERR(0, 3316, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3379 + * return (bilinterms, quadterms, linterms) + * + * def setRelaxSolVal(self, Variable var, val): # <<<<<<<<<<<<<< + * """sets the value of the given variable in the global relaxation solution""" + * PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val)) + */ + __pyx_tuple__885 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_val); if (unlikely(!__pyx_tuple__885)) __PYX_ERR(0, 3379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__885); + __Pyx_GIVEREF(__pyx_tuple__885); + __pyx_codeobj__886 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__885, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setRelaxSolVal, 3379, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__886)) __PYX_ERR(0, 3379, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3383 + * PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val)) + * + * def getConss(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve all constraints. + * + */ + __pyx_tuple__887 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_transformed, __pyx_n_s_conss_2, __pyx_n_s_nconss_2, __pyx_n_s_conss, __pyx_n_s_i); if (unlikely(!__pyx_tuple__887)) __PYX_ERR(0, 3383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__887); + __Pyx_GIVEREF(__pyx_tuple__887); + __pyx_codeobj__888 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__887, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getConss, 3383, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__888)) __PYX_ERR(0, 3383, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3400 + * return [Constraint.create(_conss[i]) for i in range(_nconss)] + * + * def getNConss(self, transformed=True): # <<<<<<<<<<<<<< + * """Retrieve number of all constraints""" + * if transformed: + */ + __pyx_codeobj__889 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__716, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNConss, 3400, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__889)) __PYX_ERR(0, 3400, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3407 + * return SCIPgetNOrigConss(self._scip) + * + * def delCons(self, Constraint cons): # <<<<<<<<<<<<<< + * """Delete constraint from the model + * + */ + __pyx_codeobj__890 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__837, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_delCons, 3407, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__890)) __PYX_ERR(0, 3407, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3415 + * PY_SCIP_CALL(SCIPdelCons(self._scip, cons.scip_cons)) + * + * def delConsLocal(self, Constraint cons): # <<<<<<<<<<<<<< + * """Delete constraint from the current node and it's children + * + */ + __pyx_codeobj__891 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__837, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_delConsLocal, 3415, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__891)) __PYX_ERR(0, 3415, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3423 + * PY_SCIP_CALL(SCIPdelConsLocal(self._scip, cons.scip_cons)) + * + * def getValsLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the coefficients of a linear constraint + * + */ + __pyx_tuple__892 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_vals_2, __pyx_n_s_vars_2, __pyx_n_s_constype, __pyx_n_s_valsdict, __pyx_n_s_i); if (unlikely(!__pyx_tuple__892)) __PYX_ERR(0, 3423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__892); + __Pyx_GIVEREF(__pyx_tuple__892); + __pyx_codeobj__893 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__892, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getValsLinear, 3423, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__893)) __PYX_ERR(0, 3423, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3444 + * return valsdict + * + * def getRowLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the linear relaxation of the given linear constraint as a row. + * may return NULL if no LP row was yet created; the user must not modify the row! + */ + __pyx_tuple__894 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_constype, __pyx_n_s_row); if (unlikely(!__pyx_tuple__894)) __PYX_ERR(0, 3444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__894); + __Pyx_GIVEREF(__pyx_tuple__894); + __pyx_codeobj__895 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__894, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getRowLinear, 3444, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__895)) __PYX_ERR(0, 3444, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3458 + * return Row.create(row) + * + * def getDualsolLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the dual solution to a linear constraint. + * + */ + __pyx_tuple__896 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_constype, __pyx_n_s_transcons); if (unlikely(!__pyx_tuple__896)) __PYX_ERR(0, 3458, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__896); + __Pyx_GIVEREF(__pyx_tuple__896); + __pyx_codeobj__897 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__896, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDualsolLinear, 3458, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__897)) __PYX_ERR(0, 3458, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3473 + * return SCIPgetDualsolLinear(self._scip, transcons.scip_cons) + * + * def getDualMultiplier(self, Constraint cons): # <<<<<<<<<<<<<< + * """DEPRECATED: Retrieve the dual solution to a linear constraint. + * + */ + __pyx_codeobj__898 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__837, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDualMultiplier, 3473, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__898)) __PYX_ERR(0, 3473, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3482 + * return self.getDualsolLinear(cons) + * + * def getDualfarkasLinear(self, Constraint cons): # <<<<<<<<<<<<<< + * """Retrieve the dual farkas value to a linear constraint. + * + */ + __pyx_codeobj__899 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__867, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDualfarkasLinear, 3482, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__899)) __PYX_ERR(0, 3482, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3495 + * return SCIPgetDualfarkasLinear(self._scip, cons.scip_cons) + * + * def getVarRedcost(self, Variable var): # <<<<<<<<<<<<<< + * """Retrieve the reduced cost of a variable. + * + */ + __pyx_tuple__900 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_redcost); if (unlikely(!__pyx_tuple__900)) __PYX_ERR(0, 3495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__900); + __Pyx_GIVEREF(__pyx_tuple__900); + __pyx_codeobj__901 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__900, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVarRedcost, 3495, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__901)) __PYX_ERR(0, 3495, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3510 + * return redcost + * + * def getDualSolVal(self, Constraint cons, boundconstraint=False): # <<<<<<<<<<<<<< + * """Retrieve returns dual solution value of a constraint. + * + */ + __pyx_tuple__902 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_cons, __pyx_n_s_boundconstraint, __pyx_n_s_dualsol_2, __pyx_n_s_bounded); if (unlikely(!__pyx_tuple__902)) __PYX_ERR(0, 3510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__902); + __Pyx_GIVEREF(__pyx_tuple__902); + __pyx_codeobj__903 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__902, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDualSolVal, 3510, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__903)) __PYX_ERR(0, 3510, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3527 + * return _dualsol + * + * def optimize(self): # <<<<<<<<<<<<<< + * """Optimize the problem.""" + * PY_SCIP_CALL(SCIPsolve(self._scip)) + */ + __pyx_codeobj__904 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_optimize, 3527, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__904)) __PYX_ERR(0, 3527, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3532 + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * + * def solveConcurrent(self): # <<<<<<<<<<<<<< + * """Transforms, presolves, and solves problem using additional solvers which emphasize on + * finding solutions.""" + */ + __pyx_codeobj__905 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_solveConcurrent, 3532, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__905)) __PYX_ERR(0, 3532, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3542 + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + * + * def presolve(self): # <<<<<<<<<<<<<< + * """Presolve the problem.""" + * PY_SCIP_CALL(SCIPpresolve(self._scip)) + */ + __pyx_codeobj__906 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_presolve, 3542, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__906)) __PYX_ERR(0, 3542, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3547 + * + * # Benders' decomposition methods + * def initBendersDefault(self, subproblems): # <<<<<<<<<<<<<< + * """initialises the default Benders' decomposition with a dictionary of subproblems + * + */ + __pyx_tuple__907 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_subproblems, __pyx_n_s_subprobs, __pyx_n_s_benders, __pyx_n_s_isdict, __pyx_n_s_nsubproblems, __pyx_n_s_idx, __pyx_n_s_subprob); if (unlikely(!__pyx_tuple__907)) __PYX_ERR(0, 3547, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__907); + __Pyx_GIVEREF(__pyx_tuple__907); + __pyx_codeobj__908 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__907, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_initBendersDefault, 3547, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__908)) __PYX_ERR(0, 3547, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3583 + * #self.setIntParam("limits/maxorigsol", 0) + * + * def computeBestSolSubproblems(self): # <<<<<<<<<<<<<< + * """Solves the subproblems with the best solution to the master problem. + * Afterwards, the best solution from each subproblem can be queried to get + */ + __pyx_tuple__909 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_benders_2, __pyx_n_s_infeasible_2, __pyx_n_s_nbenders, __pyx_n_s_nsubproblems, __pyx_n_s_solvecip, __pyx_n_s_i, __pyx_n_s_j); if (unlikely(!__pyx_tuple__909)) __PYX_ERR(0, 3583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__909); + __Pyx_GIVEREF(__pyx_tuple__909); + __pyx_codeobj__910 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__909, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_computeBestSolSubproblems, 3583, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__910)) __PYX_ERR(0, 3583, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3610 + * _benders[i], self._bestSol.sol, j, &_infeasible, solvecip, NULL)) + * + * def freeBendersSubproblems(self): # <<<<<<<<<<<<<< + * """Calls the free subproblem function for the Benders' decomposition. + * This will free all subproblems for all decompositions. + */ + __pyx_tuple__911 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_benders_2, __pyx_n_s_nbenders, __pyx_n_s_nsubproblems, __pyx_n_s_i, __pyx_n_s_j); if (unlikely(!__pyx_tuple__911)) __PYX_ERR(0, 3610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__911); + __Pyx_GIVEREF(__pyx_tuple__911); + __pyx_codeobj__912 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__911, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_freeBendersSubproblems, 3610, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__912)) __PYX_ERR(0, 3610, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3628 + * j)) + * + * def updateBendersLowerbounds(self, lowerbounds, Benders benders=None): # <<<<<<<<<<<<<< + * """"updates the subproblem lower bounds for benders using + * the lowerbounds dict. If benders is None, then the default + */ + __pyx_tuple__913 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_lowerbounds, __pyx_n_s_benders, __pyx_n_s_benders_2, __pyx_n_s_d); if (unlikely(!__pyx_tuple__913)) __PYX_ERR(0, 3628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__913); + __Pyx_GIVEREF(__pyx_tuple__913); + __pyx_codeobj__914 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__913, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_updateBendersLowerbounds, 3628, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__914)) __PYX_ERR(0, 3628, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3645 + * SCIPbendersUpdateSubproblemLowerbound(_benders, d, lowerbounds[d]) + * + * def activateBenders(self, Benders benders, int nsubproblems): # <<<<<<<<<<<<<< + * """Activates the Benders' decomposition plugin with the input name + * + */ + __pyx_tuple__915 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_benders, __pyx_n_s_nsubproblems); if (unlikely(!__pyx_tuple__915)) __PYX_ERR(0, 3645, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__915); + __Pyx_GIVEREF(__pyx_tuple__915); + __pyx_codeobj__916 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__915, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_activateBenders, 3645, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__916)) __PYX_ERR(0, 3645, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3654 + * PY_SCIP_CALL(SCIPactivateBenders(self._scip, benders._benders, nsubproblems)) + * + * def addBendersSubproblem(self, Benders benders, subproblem): # <<<<<<<<<<<<<< + * """adds a subproblem to the Benders' decomposition given by the input + * name. + */ + __pyx_tuple__917 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_benders, __pyx_n_s_subproblem); if (unlikely(!__pyx_tuple__917)) __PYX_ERR(0, 3654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__917); + __Pyx_GIVEREF(__pyx_tuple__917); + __pyx_codeobj__918 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__917, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addBendersSubproblem, 3654, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__918)) __PYX_ERR(0, 3654, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3665 + * PY_SCIP_CALL(SCIPaddBendersSubproblem(self._scip, benders._benders, (subproblem)._scip)) + * + * def setBendersSubproblemIsConvex(self, Benders benders, probnumber, isconvex = True): # <<<<<<<<<<<<<< + * """sets a flag indicating whether the subproblem is convex + * + */ + __pyx_tuple__919 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_benders, __pyx_n_s_probnumber, __pyx_n_s_isconvex); if (unlikely(!__pyx_tuple__919)) __PYX_ERR(0, 3665, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__919); + __Pyx_GIVEREF(__pyx_tuple__919); + __pyx_codeobj__920 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__919, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setBendersSubproblemIsConvex, 3665, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__920)) __PYX_ERR(0, 3665, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3675 + * SCIPbendersSetSubproblemIsConvex(benders._benders, probnumber, isconvex) + * + * def setupBendersSubproblem(self, probnumber, Benders benders = None, Solution solution = None, checktype = PY_SCIP_BENDERSENFOTYPE.LP): # <<<<<<<<<<<<<< + * """ sets up the Benders' subproblem given the master problem solution + * + */ + __pyx_tuple__921 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_probnumber, __pyx_n_s_benders, __pyx_n_s_solution, __pyx_n_s_checktype, __pyx_n_s_scip_benders, __pyx_n_s_scip_sol, __pyx_n_s_retcode); if (unlikely(!__pyx_tuple__921)) __PYX_ERR(0, 3675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__921); + __Pyx_GIVEREF(__pyx_tuple__921); + __pyx_codeobj__922 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__921, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setupBendersSubproblem, 3675, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__922)) __PYX_ERR(0, 3675, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3702 + * PY_SCIP_CALL(retcode) + * + * def solveBendersSubproblem(self, probnumber, solvecip, Benders benders = None, Solution solution = None): # <<<<<<<<<<<<<< + * """ solves the Benders' decomposition subproblem. The convex relaxation will be solved unless + * the parameter solvecip is set to True. + */ + __pyx_tuple__923 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_probnumber, __pyx_n_s_solvecip, __pyx_n_s_benders, __pyx_n_s_solution, __pyx_n_s_scip_benders, __pyx_n_s_scip_sol, __pyx_n_s_objective, __pyx_n_s_infeasible); if (unlikely(!__pyx_tuple__923)) __PYX_ERR(0, 3702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__923); + __Pyx_GIVEREF(__pyx_tuple__923); + __pyx_codeobj__924 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__923, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_solveBendersSubproblem, 3702, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__924)) __PYX_ERR(0, 3702, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3733 + * return infeasible, objective + * + * def getBendersSubproblem(self, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns a Model object that wraps around the SCIP instance of the subproblem. + * NOTE: This Model object is just a place holder and SCIP instance will not be freed when the object is destroyed. + */ + __pyx_tuple__925 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_probnumber, __pyx_n_s_benders, __pyx_n_s_scip_benders, __pyx_n_s_scip_subprob); if (unlikely(!__pyx_tuple__925)) __PYX_ERR(0, 3733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__925); + __Pyx_GIVEREF(__pyx_tuple__925); + __pyx_codeobj__926 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__925, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBendersSubproblem, 3733, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__926)) __PYX_ERR(0, 3733, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3753 + * return Model.create(scip_subprob) + * + * def getBendersVar(self, Variable var, Benders benders = None, probnumber = -1): # <<<<<<<<<<<<<< + * """Returns the variable for the subproblem or master problem + * depending on the input probnumber + */ + __pyx_tuple__927 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_benders, __pyx_n_s_probnumber, __pyx_n_s_benders_2, __pyx_n_s_mappedvar_2, __pyx_n_s_mappedvar); if (unlikely(!__pyx_tuple__927)) __PYX_ERR(0, 3753, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__927); + __Pyx_GIVEREF(__pyx_tuple__927); + __pyx_codeobj__928 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__927, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBendersVar, 3753, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__928)) __PYX_ERR(0, 3753, __pyx_L1_error) + __pyx_tuple__929 = PyTuple_Pack(2, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__929)) __PYX_ERR(0, 3753, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__929); + __Pyx_GIVEREF(__pyx_tuple__929); + + /* "src/pyscipopt/scip.pxi":3782 + * return mappedvar + * + * def getBendersAuxiliaryVar(self, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns the auxiliary variable that is associated with the input problem number + * + */ + __pyx_tuple__930 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_probnumber, __pyx_n_s_benders, __pyx_n_s_benders_2, __pyx_n_s_auxvar, __pyx_n_s_auxvar_2); if (unlikely(!__pyx_tuple__930)) __PYX_ERR(0, 3782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__930); + __Pyx_GIVEREF(__pyx_tuple__930); + __pyx_codeobj__931 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__930, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBendersAuxiliaryVar, 3782, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__931)) __PYX_ERR(0, 3782, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3802 + * return auxvar + * + * def checkBendersSubproblemOptimality(self, Solution solution, probnumber, Benders benders = None): # <<<<<<<<<<<<<< + * """Returns whether the subproblem is optimal w.r.t the master problem auxiliary variables. + * + */ + __pyx_tuple__932 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_probnumber, __pyx_n_s_benders, __pyx_n_s_benders_2, __pyx_n_s_scip_sol, __pyx_n_s_optimal); if (unlikely(!__pyx_tuple__932)) __PYX_ERR(0, 3802, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__932); + __Pyx_GIVEREF(__pyx_tuple__932); + __pyx_codeobj__933 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__932, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_checkBendersSubproblemOptimality, 3802, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__933)) __PYX_ERR(0, 3802, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3829 + * return optimal + * + * def includeBendersDefaultCuts(self, Benders benders): # <<<<<<<<<<<<<< + * """includes the default Benders' decomposition cuts to the custom Benders' decomposition plugin + * + */ + __pyx_tuple__934 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_benders); if (unlikely(!__pyx_tuple__934)) __PYX_ERR(0, 3829, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__934); + __Pyx_GIVEREF(__pyx_tuple__934); + __pyx_codeobj__935 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__934, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeBendersDefaultCuts, 3829, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__935)) __PYX_ERR(0, 3829, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3838 + * + * + * def includeEventhdlr(self, Eventhdlr eventhdlr, name, desc): # <<<<<<<<<<<<<< + * """Include an event handler. + * + */ + __pyx_tuple__936 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_eventhdlr, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_n, __pyx_n_s_d); if (unlikely(!__pyx_tuple__936)) __PYX_ERR(0, 3838, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__936); + __Pyx_GIVEREF(__pyx_tuple__936); + __pyx_codeobj__937 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__936, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeEventhdlr, 3838, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__937)) __PYX_ERR(0, 3838, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3862 + * Py_INCREF(eventhdlr) + * + * def includePricer(self, Pricer pricer, name, desc, priority=1, delay=True): # <<<<<<<<<<<<<< + * """Include a pricer. + * + */ + __pyx_tuple__938 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_pricer, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_priority, __pyx_n_s_delay, __pyx_n_s_n, __pyx_n_s_d, __pyx_n_s_scip_pricer); if (unlikely(!__pyx_tuple__938)) __PYX_ERR(0, 3862, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__938); + __Pyx_GIVEREF(__pyx_tuple__938); + __pyx_codeobj__939 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__938, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includePricer, 3862, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__939)) __PYX_ERR(0, 3862, __pyx_L1_error) + __pyx_tuple__940 = PyTuple_Pack(2, __pyx_int_1, Py_True); if (unlikely(!__pyx_tuple__940)) __PYX_ERR(0, 3862, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__940); + __Pyx_GIVEREF(__pyx_tuple__940); + + /* "src/pyscipopt/scip.pxi":3884 + * Py_INCREF(pricer) + * + * def includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0, # <<<<<<<<<<<<<< + * enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1, + * eagerfreq=100, maxprerounds=-1, delaysepa=False, + */ + __pyx_tuple__941 = PyTuple_Pack(18, __pyx_n_s_self, __pyx_n_s_conshdlr, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_sepapriority, __pyx_n_s_enfopriority, __pyx_n_s_chckpriority, __pyx_n_s_sepafreq, __pyx_n_s_propfreq, __pyx_n_s_eagerfreq, __pyx_n_s_maxprerounds, __pyx_n_s_delaysepa, __pyx_n_s_delayprop, __pyx_n_s_needscons, __pyx_n_s_proptiming, __pyx_n_s_presoltiming, __pyx_n_s_n, __pyx_n_s_d); if (unlikely(!__pyx_tuple__941)) __PYX_ERR(0, 3884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__941); + __Pyx_GIVEREF(__pyx_tuple__941); + __pyx_codeobj__942 = (PyObject*)__Pyx_PyCode_New(16, 0, 0, 18, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__941, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeConshdlr, 3884, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__942)) __PYX_ERR(0, 3884, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3923 + * Py_INCREF(conshdlr) + * + * def createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True, # <<<<<<<<<<<<<< + * local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False): + * """Create a constraint of a custom constraint handler + */ + __pyx_tuple__943 = PyTuple_Pack(16, __pyx_n_s_self, __pyx_n_s_conshdlr, __pyx_n_s_name, __pyx_n_s_initial, __pyx_n_s_separate, __pyx_n_s_enforce, __pyx_n_s_check, __pyx_n_s_propagate, __pyx_n_s_local, __pyx_n_s_modifiable, __pyx_n_s_dynamic, __pyx_n_s_removable, __pyx_n_s_stickingatnode, __pyx_n_s_n, __pyx_n_s_scip_conshdlr, __pyx_n_s_constraint); if (unlikely(!__pyx_tuple__943)) __PYX_ERR(0, 3923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__943); + __Pyx_GIVEREF(__pyx_tuple__943); + __pyx_codeobj__944 = (PyObject*)__Pyx_PyCode_New(13, 0, 0, 16, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__943, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createCons, 3923, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__944)) __PYX_ERR(0, 3923, __pyx_L1_error) + __pyx_tuple__945 = PyTuple_Pack(10, Py_True, Py_True, Py_True, Py_True, Py_True, Py_False, Py_False, Py_False, Py_False, Py_False); if (unlikely(!__pyx_tuple__945)) __PYX_ERR(0, 3923, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__945); + __Pyx_GIVEREF(__pyx_tuple__945); + + /* "src/pyscipopt/scip.pxi":3950 + * return constraint + * + * def includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=SCIP_PRESOLTIMING_FAST): # <<<<<<<<<<<<<< + * """Include a presolver + * + */ + __pyx_tuple__946 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_presol, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_priority, __pyx_n_s_maxrounds, __pyx_n_s_timing, __pyx_n_s_n, __pyx_n_s_d); if (unlikely(!__pyx_tuple__946)) __PYX_ERR(0, 3950, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__946); + __Pyx_GIVEREF(__pyx_tuple__946); + __pyx_codeobj__947 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__946, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includePresol, 3950, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__947)) __PYX_ERR(0, 3950, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":3968 + * Py_INCREF(presol) + * + * def includeSepa(self, Sepa sepa, name, desc, priority=0, freq=10, maxbounddist=1.0, usessubscip=False, delay=False): # <<<<<<<<<<<<<< + * """Include a separator + * + */ + __pyx_tuple__948 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_sepa, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_priority, __pyx_n_s_freq, __pyx_n_s_maxbounddist, __pyx_n_s_usessubscip, __pyx_n_s_delay, __pyx_n_s_n, __pyx_n_s_d); if (unlikely(!__pyx_tuple__948)) __PYX_ERR(0, 3968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__948); + __Pyx_GIVEREF(__pyx_tuple__948); + __pyx_codeobj__949 = (PyObject*)__Pyx_PyCode_New(9, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__948, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeSepa, 3968, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__949)) __PYX_ERR(0, 3968, __pyx_L1_error) + __pyx_tuple__950 = PyTuple_Pack(5, __pyx_int_0, __pyx_int_10, __pyx_float_1_0, Py_False, Py_False); if (unlikely(!__pyx_tuple__950)) __PYX_ERR(0, 3968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__950); + __Pyx_GIVEREF(__pyx_tuple__950); + + /* "src/pyscipopt/scip.pxi":3989 + * Py_INCREF(sepa) + * + * def includeReader(self, Reader reader, name, desc, ext): # <<<<<<<<<<<<<< + * """Include a reader + * + */ + __pyx_tuple__951 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_reader, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_ext, __pyx_n_s_n, __pyx_n_s_d, __pyx_n_s_e); if (unlikely(!__pyx_tuple__951)) __PYX_ERR(0, 3989, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__951); + __Pyx_GIVEREF(__pyx_tuple__951); + __pyx_codeobj__952 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__951, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeReader, 3989, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__952)) __PYX_ERR(0, 3989, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4007 + * Py_INCREF(reader) + * + * def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds, # <<<<<<<<<<<<<< + * proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True): + * """Include a propagator. + */ + __pyx_tuple__953 = PyTuple_Pack(13, __pyx_n_s_self, __pyx_n_s_prop, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_presolpriority, __pyx_n_s_presolmaxrounds, __pyx_n_s_proptiming, __pyx_n_s_presoltiming, __pyx_n_s_priority, __pyx_n_s_freq, __pyx_n_s_delay, __pyx_n_s_n, __pyx_n_s_d); if (unlikely(!__pyx_tuple__953)) __PYX_ERR(0, 4007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__953); + __Pyx_GIVEREF(__pyx_tuple__953); + __pyx_codeobj__954 = (PyObject*)__Pyx_PyCode_New(11, 0, 0, 13, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__953, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeProp, 4007, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__954)) __PYX_ERR(0, 4007, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4035 + * Py_INCREF(prop) + * + * def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0, # <<<<<<<<<<<<<< + * maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False): + * """Include a primal heuristic. + */ + __pyx_tuple__955 = PyTuple_Pack(14, __pyx_n_s_self, __pyx_n_s_heur, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_dispchar, __pyx_n_s_priority, __pyx_n_s_freq, __pyx_n_s_freqofs, __pyx_n_s_maxdepth, __pyx_n_s_timingmask, __pyx_n_s_usessubscip, __pyx_n_s_nam, __pyx_n_s_des, __pyx_n_s_dis); if (unlikely(!__pyx_tuple__955)) __PYX_ERR(0, 4035, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__955); + __Pyx_GIVEREF(__pyx_tuple__955); + __pyx_codeobj__956 = (PyObject*)__Pyx_PyCode_New(11, 0, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__955, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeHeur, 4035, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__956)) __PYX_ERR(0, 4035, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4064 + * Py_INCREF(heur) + * + * def includeRelax(self, Relax relax, name, desc, priority=10000, freq=1): # <<<<<<<<<<<<<< + * """Include a relaxation handler. + * + */ + __pyx_tuple__957 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_relax, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_priority, __pyx_n_s_freq, __pyx_n_s_nam, __pyx_n_s_des); if (unlikely(!__pyx_tuple__957)) __PYX_ERR(0, 4064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__957); + __Pyx_GIVEREF(__pyx_tuple__957); + __pyx_codeobj__958 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__957, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeRelax, 4064, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__958)) __PYX_ERR(0, 4064, __pyx_L1_error) + __pyx_tuple__959 = PyTuple_Pack(2, __pyx_int_10000, __pyx_int_1); if (unlikely(!__pyx_tuple__959)) __PYX_ERR(0, 4064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__959); + __Pyx_GIVEREF(__pyx_tuple__959); + + /* "src/pyscipopt/scip.pxi":4083 + * Py_INCREF(relax) + * + * def includeCutsel(self, Cutsel cutsel, name, desc, priority): # <<<<<<<<<<<<<< + * """include a cut selector + * + */ + __pyx_tuple__960 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_cutsel, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_priority, __pyx_n_s_nam, __pyx_n_s_des); if (unlikely(!__pyx_tuple__960)) __PYX_ERR(0, 4083, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__960); + __Pyx_GIVEREF(__pyx_tuple__960); + __pyx_codeobj__961 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__960, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeCutsel, 4083, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__961)) __PYX_ERR(0, 4083, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4101 + * Py_INCREF(cutsel) + * + * def includeBranchrule(self, Branchrule branchrule, name, desc, priority, maxdepth, maxbounddist): # <<<<<<<<<<<<<< + * """Include a branching rule. + * + */ + __pyx_tuple__962 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_branchrule, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_priority, __pyx_n_s_maxdepth, __pyx_n_s_maxbounddist, __pyx_n_s_nam, __pyx_n_s_des); if (unlikely(!__pyx_tuple__962)) __PYX_ERR(0, 4101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__962); + __Pyx_GIVEREF(__pyx_tuple__962); + __pyx_codeobj__963 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__962, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeBranchrule, 4101, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__963)) __PYX_ERR(0, 4101, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4122 + * Py_INCREF(branchrule) + * + * def includeNodesel(self, Nodesel nodesel, name, desc, stdpriority, memsavepriority): # <<<<<<<<<<<<<< + * """Include a node selector. + * + */ + __pyx_tuple__964 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_nodesel, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_stdpriority, __pyx_n_s_memsavepriority, __pyx_n_s_nam, __pyx_n_s_des); if (unlikely(!__pyx_tuple__964)) __PYX_ERR(0, 4122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__964); + __Pyx_GIVEREF(__pyx_tuple__964); + __pyx_codeobj__965 = (PyObject*)__Pyx_PyCode_New(6, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__964, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeNodesel, 4122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__965)) __PYX_ERR(0, 4122, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4142 + * Py_INCREF(nodesel) + * + * def includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True, # <<<<<<<<<<<<<< + * shareaux=False): + * """Include a Benders' decomposition. + */ + __pyx_tuple__966 = PyTuple_Pack(12, __pyx_n_s_self, __pyx_n_s_benders, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_priority, __pyx_n_s_cutlp, __pyx_n_s_cutpseudo, __pyx_n_s_cutrelax, __pyx_n_s_shareaux, __pyx_n_s_n, __pyx_n_s_d, __pyx_n_s_scip_benders); if (unlikely(!__pyx_tuple__966)) __PYX_ERR(0, 4142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__966); + __Pyx_GIVEREF(__pyx_tuple__966); + __pyx_codeobj__967 = (PyObject*)__Pyx_PyCode_New(9, 0, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__966, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeBenders, 4142, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__967)) __PYX_ERR(0, 4142, __pyx_L1_error) + __pyx_tuple__968 = PyTuple_Pack(5, __pyx_int_1, Py_True, Py_True, Py_True, Py_False); if (unlikely(!__pyx_tuple__968)) __PYX_ERR(0, 4142, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__968); + __Pyx_GIVEREF(__pyx_tuple__968); + + /* "src/pyscipopt/scip.pxi":4172 + * Py_INCREF(benders) + * + * def includeBenderscut(self, Benders benders, Benderscut benderscut, name, desc, priority=1, islpcut=True): # <<<<<<<<<<<<<< + * """ Include a Benders' decomposition cutting method + * + */ + __pyx_tuple__969 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_benders, __pyx_n_s_benderscut, __pyx_n_s_name, __pyx_n_s_desc, __pyx_n_s_priority, __pyx_n_s_islpcut, __pyx_n_s_benders_2, __pyx_n_s_n, __pyx_n_s_d, __pyx_n_s_scip_benderscut); if (unlikely(!__pyx_tuple__969)) __PYX_ERR(0, 4172, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__969); + __Pyx_GIVEREF(__pyx_tuple__969); + __pyx_codeobj__970 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__969, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_includeBenderscut, 4172, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__970)) __PYX_ERR(0, 4172, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4203 + * + * + * def getLPBranchCands(self): # <<<<<<<<<<<<<< + * """gets branching candidates for LP solution branching (fractional variables) along with solution values, + * fractionalities, and number of branching candidates; The number of branching candidates does NOT account + */ + __pyx_tuple__971 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_ncands, __pyx_n_s_nlpcands, __pyx_n_s_npriolpcands, __pyx_n_s_nfracimplvars, __pyx_n_s_lpcands, __pyx_n_s_lpcandssol, __pyx_n_s_lpcandsfrac, __pyx_n_s_i, __pyx_n_s_i, __pyx_n_s_i); if (unlikely(!__pyx_tuple__971)) __PYX_ERR(0, 4203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__971); + __Pyx_GIVEREF(__pyx_tuple__971); + __pyx_codeobj__972 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__971, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getLPBranchCands, 4203, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__972)) __PYX_ERR(0, 4203, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4235 + * [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars) + * + * def getPseudoBranchCands(self): # <<<<<<<<<<<<<< + * """gets branching candidates for pseudo solution branching (non-fixed variables) + * along with the number of candidates. + */ + __pyx_tuple__973 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_npseudocands, __pyx_n_s_npriopseudocands, __pyx_n_s_pseudocands, __pyx_n_s_i); if (unlikely(!__pyx_tuple__973)) __PYX_ERR(0, 4235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__973); + __Pyx_GIVEREF(__pyx_tuple__973); + __pyx_codeobj__974 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__973, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getPseudoBranchCands, 4235, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__974)) __PYX_ERR(0, 4235, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4255 + * return ([Variable.create(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands) + * + * def branchVar(self, Variable variable): # <<<<<<<<<<<<<< + * """Branch on a non-continuous variable. + * + */ + __pyx_tuple__975 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_variable, __pyx_n_s_downchild, __pyx_n_s_eqchild, __pyx_n_s_upchild); if (unlikely(!__pyx_tuple__975)) __PYX_ERR(0, 4255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__975); + __Pyx_GIVEREF(__pyx_tuple__975); + __pyx_codeobj__976 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__975, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_branchVar, 4255, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__976)) __PYX_ERR(0, 4255, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4271 + * + * + * def branchVarVal(self, variable, value): # <<<<<<<<<<<<<< + * """Branches on variable using a value which separates the domain of the variable. + * + */ + __pyx_tuple__977 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_variable, __pyx_n_s_value, __pyx_n_s_downchild, __pyx_n_s_eqchild, __pyx_n_s_upchild); if (unlikely(!__pyx_tuple__977)) __PYX_ERR(0, 4271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__977); + __Pyx_GIVEREF(__pyx_tuple__977); + __pyx_codeobj__978 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__977, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_branchVarVal, 4271, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__978)) __PYX_ERR(0, 4271, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4288 + * return Node.create(downchild), Node.create(eqchild), Node.create(upchild) + * + * def calcNodeselPriority(self, Variable variable, branchdir, targetvalue): # <<<<<<<<<<<<<< + * """calculates the node selection priority for moving the given variable's LP value + * to the given target value; + */ + __pyx_tuple__979 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_variable, __pyx_n_s_branchdir, __pyx_n_s_targetvalue); if (unlikely(!__pyx_tuple__979)) __PYX_ERR(0, 4288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__979); + __Pyx_GIVEREF(__pyx_tuple__979); + __pyx_codeobj__980 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__979, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_calcNodeselPriority, 4288, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__980)) __PYX_ERR(0, 4288, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4301 + * return SCIPcalcNodeselPriority(self._scip, variable.scip_var, branchdir, targetvalue) + * + * def calcChildEstimate(self, Variable variable, targetvalue): # <<<<<<<<<<<<<< + * """Calculates an estimate for the objective of the best feasible solution + * contained in the subtree after applying the given branching; + */ + __pyx_tuple__981 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_variable, __pyx_n_s_targetvalue); if (unlikely(!__pyx_tuple__981)) __PYX_ERR(0, 4301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__981); + __Pyx_GIVEREF(__pyx_tuple__981); + __pyx_codeobj__982 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__981, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_calcChildEstimate, 4301, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__982)) __PYX_ERR(0, 4301, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4313 + * return SCIPcalcChildEstimate(self._scip, variable.scip_var, targetvalue) + * + * def createChild(self, nodeselprio, estimate): # <<<<<<<<<<<<<< + * """Create a child node of the focus node. + * + */ + __pyx_tuple__983 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_nodeselprio, __pyx_n_s_estimate, __pyx_n_s_child); if (unlikely(!__pyx_tuple__983)) __PYX_ERR(0, 4313, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__983); + __Pyx_GIVEREF(__pyx_tuple__983); + __pyx_codeobj__984 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__983, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createChild, 4313, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__984)) __PYX_ERR(0, 4313, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4326 + * + * # Diving methods (Diving is LP related) + * def startDive(self): # <<<<<<<<<<<<<< + * """Initiates LP diving + * It allows the user to change the LP in several ways, solve, change again, etc, without affecting the actual LP that has. When endDive() is called, + */ + __pyx_codeobj__985 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_startDive, 4326, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__985)) __PYX_ERR(0, 4326, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4333 + * PY_SCIP_CALL(SCIPstartDive(self._scip)) + * + * def endDive(self): # <<<<<<<<<<<<<< + * """Quits probing and resets bounds and constraints to the focus node's environment""" + * PY_SCIP_CALL(SCIPendDive(self._scip)) + */ + __pyx_codeobj__986 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_endDive, 4333, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__986)) __PYX_ERR(0, 4333, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4337 + * PY_SCIP_CALL(SCIPendDive(self._scip)) + * + * def chgVarObjDive(self, Variable var, newobj): # <<<<<<<<<<<<<< + * """changes (column) variable's objective value in current dive""" + * PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj)) + */ + __pyx_tuple__987 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_newobj); if (unlikely(!__pyx_tuple__987)) __PYX_ERR(0, 4337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__987); + __Pyx_GIVEREF(__pyx_tuple__987); + __pyx_codeobj__988 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__987, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarObjDive, 4337, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__988)) __PYX_ERR(0, 4337, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4341 + * PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj)) + * + * def chgVarLbDive(self, Variable var, newbound): # <<<<<<<<<<<<<< + * """changes variable's current lb in current dive""" + * PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound)) + */ + __pyx_tuple__989 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_newbound); if (unlikely(!__pyx_tuple__989)) __PYX_ERR(0, 4341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__989); + __Pyx_GIVEREF(__pyx_tuple__989); + __pyx_codeobj__990 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__989, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarLbDive, 4341, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__990)) __PYX_ERR(0, 4341, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4345 + * PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound)) + * + * def chgVarUbDive(self, Variable var, newbound): # <<<<<<<<<<<<<< + * """changes variable's current ub in current dive""" + * PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound)) + */ + __pyx_codeobj__991 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__989, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarUbDive, 4345, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__991)) __PYX_ERR(0, 4345, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4349 + * PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound)) + * + * def getVarLbDive(self, Variable var): # <<<<<<<<<<<<<< + * """returns variable's current lb in current dive""" + * return SCIPgetVarLbDive(self._scip, var.scip_var) + */ + __pyx_codeobj__992 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__479, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVarLbDive, 4349, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__992)) __PYX_ERR(0, 4349, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4353 + * return SCIPgetVarLbDive(self._scip, var.scip_var) + * + * def getVarUbDive(self, Variable var): # <<<<<<<<<<<<<< + * """returns variable's current ub in current dive""" + * return SCIPgetVarUbDive(self._scip, var.scip_var) + */ + __pyx_codeobj__993 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__479, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVarUbDive, 4353, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__993)) __PYX_ERR(0, 4353, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4357 + * return SCIPgetVarUbDive(self._scip, var.scip_var) + * + * def chgRowLhsDive(self, Row row, newlhs): # <<<<<<<<<<<<<< + * """changes row lhs in current dive, change will be undone after diving + * ends, for permanent changes use SCIPchgRowLhs() + */ + __pyx_tuple__994 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_row, __pyx_n_s_newlhs); if (unlikely(!__pyx_tuple__994)) __PYX_ERR(0, 4357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__994); + __Pyx_GIVEREF(__pyx_tuple__994); + __pyx_codeobj__995 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__994, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgRowLhsDive, 4357, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__995)) __PYX_ERR(0, 4357, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4363 + * PY_SCIP_CALL(SCIPchgRowLhsDive(self._scip, row.scip_row, newlhs)) + * + * def chgRowRhsDive(self, Row row, newrhs): # <<<<<<<<<<<<<< + * """changes row rhs in current dive, change will be undone after diving + * ends, for permanent changes use SCIPchgRowLhs() + */ + __pyx_tuple__996 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_row, __pyx_n_s_newrhs); if (unlikely(!__pyx_tuple__996)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__996); + __Pyx_GIVEREF(__pyx_tuple__996); + __pyx_codeobj__997 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__996, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgRowRhsDive, 4363, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__997)) __PYX_ERR(0, 4363, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4369 + * PY_SCIP_CALL(SCIPchgRowRhsDive(self._scip, row.scip_row, newrhs)) + * + * def addRowDive(self, Row row): # <<<<<<<<<<<<<< + * """adds a row to the LP in current dive""" + * PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row)) + */ + __pyx_codeobj__998 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__483, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addRowDive, 4369, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__998)) __PYX_ERR(0, 4369, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4373 + * PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row)) + * + * def solveDiveLP(self, itlim = -1): # <<<<<<<<<<<<<< + * """solves the LP of the current dive no separation or pricing is applied + * no separation or pricing is applied + */ + __pyx_tuple__999 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_itlim, __pyx_n_s_lperror, __pyx_n_s_cutoff); if (unlikely(!__pyx_tuple__999)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__999); + __Pyx_GIVEREF(__pyx_tuple__999); + __pyx_codeobj__1000 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__999, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_solveDiveLP, 4373, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1000)) __PYX_ERR(0, 4373, __pyx_L1_error) + __pyx_tuple__1001 = PyTuple_Pack(1, __pyx_int_neg_1); if (unlikely(!__pyx_tuple__1001)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1001); + __Pyx_GIVEREF(__pyx_tuple__1001); + + /* "src/pyscipopt/scip.pxi":4387 + * return lperror, cutoff + * + * def inRepropagation(self): # <<<<<<<<<<<<<< + * """returns if the current node is already solved and only propagated again.""" + * return SCIPinRepropagation(self._scip) + */ + __pyx_codeobj__1002 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_inRepropagation, 4387, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1002)) __PYX_ERR(0, 4387, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4392 + * + * # Probing methods (Probing is tree based) + * def startProbing(self): # <<<<<<<<<<<<<< + * """Initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), + * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), SCIPsolveProbingLP(), etc available + */ + __pyx_codeobj__1003 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_startProbing, 4392, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1003)) __PYX_ERR(0, 4392, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4398 + * PY_SCIP_CALL( SCIPstartProbing(self._scip) ) + * + * def endProbing(self): # <<<<<<<<<<<<<< + * """Quits probing and resets bounds and constraints to the focus node's environment""" + * PY_SCIP_CALL( SCIPendProbing(self._scip) ) + */ + __pyx_codeobj__1004 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_endProbing, 4398, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1004)) __PYX_ERR(0, 4398, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4402 + * PY_SCIP_CALL( SCIPendProbing(self._scip) ) + * + * def newProbingNode(self): # <<<<<<<<<<<<<< + * """creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the + * probing path with a call to backtrackProbing() + */ + __pyx_codeobj__1005 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_newProbingNode, 4402, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1005)) __PYX_ERR(0, 4402, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4408 + * PY_SCIP_CALL( SCIPnewProbingNode(self._scip) ) + * + * def backtrackProbing(self, probingdepth): # <<<<<<<<<<<<<< + * """undoes all changes to the problem applied in probing up to the given probing depth + * :param probingdepth: probing depth of the node in the probing path that should be reactivated + */ + __pyx_tuple__1006 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_probingdepth); if (unlikely(!__pyx_tuple__1006)) __PYX_ERR(0, 4408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1006); + __Pyx_GIVEREF(__pyx_tuple__1006); + __pyx_codeobj__1007 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1006, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_backtrackProbing, 4408, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1007)) __PYX_ERR(0, 4408, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4414 + * PY_SCIP_CALL( SCIPbacktrackProbing(self._scip, probingdepth) ) + * + * def getProbingDepth(self): # <<<<<<<<<<<<<< + * """returns the current probing depth""" + * return SCIPgetProbingDepth(self._scip) + */ + __pyx_codeobj__1008 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getProbingDepth, 4414, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1008)) __PYX_ERR(0, 4414, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4418 + * return SCIPgetProbingDepth(self._scip) + * + * def chgVarObjProbing(self, Variable var, newobj): # <<<<<<<<<<<<<< + * """changes (column) variable's objective value during probing mode""" + * PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) ) + */ + __pyx_codeobj__1009 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__987, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarObjProbing, 4418, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1009)) __PYX_ERR(0, 4418, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4422 + * PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) ) + * + * def chgVarLbProbing(self, Variable var, lb): # <<<<<<<<<<<<<< + * """changes the variable lower bound during probing mode + * + */ + __pyx_codeobj__1010 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__702, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarLbProbing, 4422, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1010)) __PYX_ERR(0, 4422, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4432 + * PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb)) + * + * def chgVarUbProbing(self, Variable var, ub): # <<<<<<<<<<<<<< + * """changes the variable upper bound during probing mode + * + */ + __pyx_codeobj__1011 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__704, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarUbProbing, 4432, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1011)) __PYX_ERR(0, 4432, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4442 + * PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub)) + * + * def fixVarProbing(self, Variable var, fixedval): # <<<<<<<<<<<<<< + * """Fixes a variable at the current probing node.""" + * PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) ) + */ + __pyx_tuple__1012 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_fixedval); if (unlikely(!__pyx_tuple__1012)) __PYX_ERR(0, 4442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1012); + __Pyx_GIVEREF(__pyx_tuple__1012); + __pyx_codeobj__1013 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1012, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_fixVarProbing, 4442, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1013)) __PYX_ERR(0, 4442, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4446 + * PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) ) + * + * def isObjChangedProbing(self): # <<<<<<<<<<<<<< + * """returns whether the objective function has changed during probing mode""" + * return SCIPisObjChangedProbing(self._scip) + */ + __pyx_codeobj__1014 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_isObjChangedProbing, 4446, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1014)) __PYX_ERR(0, 4446, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4450 + * return SCIPisObjChangedProbing(self._scip) + * + * def inProbing(self): # <<<<<<<<<<<<<< + * """returns whether we are in probing mode; probing mode is activated via startProbing() and stopped via endProbing()""" + * return SCIPinProbing(self._scip) + */ + __pyx_codeobj__1015 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_inProbing, 4450, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1015)) __PYX_ERR(0, 4450, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4454 + * return SCIPinProbing(self._scip) + * + * def solveProbingLP(self, itlim = -1): # <<<<<<<<<<<<<< + * """solves the LP at the current probing node (cannot be applied at preprocessing stage) + * no separation or pricing is applied + */ + __pyx_codeobj__1016 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__999, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_solveProbingLP, 4454, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1016)) __PYX_ERR(0, 4454, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4468 + * return lperror, cutoff + * + * def applyCutsProbing(self): # <<<<<<<<<<<<<< + * """applies the cuts in the separation storage to the LP and clears the storage afterwards; + * this method can only be applied during probing; the user should resolve the probing LP afterwards + */ + __pyx_codeobj__1017 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__734, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_applyCutsProbing, 4468, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1017)) __PYX_ERR(0, 4468, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4480 + * return cutoff + * + * def propagateProbing(self, maxproprounds): # <<<<<<<<<<<<<< + * """applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; + * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() + */ + __pyx_tuple__1018 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_maxproprounds, __pyx_n_s_cutoff, __pyx_n_s_ndomredsfound); if (unlikely(!__pyx_tuple__1018)) __PYX_ERR(0, 4480, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1018); + __Pyx_GIVEREF(__pyx_tuple__1018); + __pyx_codeobj__1019 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1018, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_propagateProbing, 4480, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1019)) __PYX_ERR(0, 4480, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4496 + * return cutoff, ndomredsfound + * + * def interruptSolve(self): # <<<<<<<<<<<<<< + * """Interrupt the solving process as soon as possible.""" + * PY_SCIP_CALL(SCIPinterruptSolve(self._scip)) + */ + __pyx_codeobj__1020 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_interruptSolve, 4496, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1020)) __PYX_ERR(0, 4496, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4500 + * PY_SCIP_CALL(SCIPinterruptSolve(self._scip)) + * + * def restartSolve(self): # <<<<<<<<<<<<<< + * """Restarts the solving process as soon as possible.""" + * PY_SCIP_CALL(SCIPrestartSolve(self._scip)) + */ + __pyx_codeobj__1021 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_restartSolve, 4500, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1021)) __PYX_ERR(0, 4500, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4506 + * # Solution functions + * + * def writeLP(self, filename="LP.lp"): # <<<<<<<<<<<<<< + * """writes current LP to a file + * :param filename: file name (Default value = "LP.lp") + */ + __pyx_tuple__1022 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_user_locale, __pyx_n_s_absfile); if (unlikely(!__pyx_tuple__1022)) __PYX_ERR(0, 4506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1022); + __Pyx_GIVEREF(__pyx_tuple__1022); + __pyx_codeobj__1023 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1022, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeLP, 4506, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1023)) __PYX_ERR(0, 4506, __pyx_L1_error) + __pyx_tuple__1024 = PyTuple_Pack(1, __pyx_kp_u_LP_lp); if (unlikely(!__pyx_tuple__1024)) __PYX_ERR(0, 4506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1024); + __Pyx_GIVEREF(__pyx_tuple__1024); + + /* "src/pyscipopt/scip.pxi":4518 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def createSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a new primal solution in the transformed space. + * + */ + __pyx_tuple__1025 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_heur, __pyx_n_s_heur_2, __pyx_n_s_sol_2, __pyx_n_s_n, __pyx_n_s_solution); if (unlikely(!__pyx_tuple__1025)) __PYX_ERR(0, 4518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1025); + __Pyx_GIVEREF(__pyx_tuple__1025); + __pyx_codeobj__1026 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1025, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createSol, 4518, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1026)) __PYX_ERR(0, 4518, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4536 + * return solution + * + * def createPartialSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a partial primal solution, initialized to unknown values. + * :param Heur heur: heuristic that found the solution (Default value = None) + */ + __pyx_tuple__1027 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_heur, __pyx_n_s_heur_2, __pyx_n_s_sol_2, __pyx_n_s_n, __pyx_n_s_partialsolution); if (unlikely(!__pyx_tuple__1027)) __PYX_ERR(0, 4536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1027); + __Pyx_GIVEREF(__pyx_tuple__1027); + __pyx_codeobj__1028 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1027, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createPartialSol, 4536, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1028)) __PYX_ERR(0, 4536, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4553 + * return partialsolution + * + * def createOrigSol(self, Heur heur = None): # <<<<<<<<<<<<<< + * """Create a new primal solution in the original space. + * + */ + __pyx_codeobj__1029 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1025, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_createOrigSol, 4553, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1029)) __PYX_ERR(0, 4553, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4572 + * return solution + * + * def printBestSol(self, write_zeros=False): # <<<<<<<<<<<<<< + * """Prints the best feasible primal solution.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + __pyx_tuple__1030 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_write_zeros, __pyx_n_s_user_locale); if (unlikely(!__pyx_tuple__1030)) __PYX_ERR(0, 4572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1030); + __Pyx_GIVEREF(__pyx_tuple__1030); + __pyx_codeobj__1031 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1030, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_printBestSol, 4572, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1031)) __PYX_ERR(0, 4572, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4581 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def printSol(self, Solution solution=None, write_zeros=False): # <<<<<<<<<<<<<< + * """Print the given primal solution. + * + */ + __pyx_tuple__1032 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_write_zeros, __pyx_n_s_user_locale); if (unlikely(!__pyx_tuple__1032)) __PYX_ERR(0, 4581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1032); + __Pyx_GIVEREF(__pyx_tuple__1032); + __pyx_codeobj__1033 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1032, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_printSol, 4581, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1033)) __PYX_ERR(0, 4581, __pyx_L1_error) + __pyx_tuple__1034 = PyTuple_Pack(2, Py_None, Py_False); if (unlikely(!__pyx_tuple__1034)) __PYX_ERR(0, 4581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1034); + __Pyx_GIVEREF(__pyx_tuple__1034); + + /* "src/pyscipopt/scip.pxi":4599 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeBestSol(self, filename="origprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the best feasible primal solution to a file. + * + */ + __pyx_tuple__1035 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_write_zeros, __pyx_n_s_user_locale, __pyx_n_s_f, __pyx_n_s_cfile); if (unlikely(!__pyx_tuple__1035)) __PYX_ERR(0, 4599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1035); + __Pyx_GIVEREF(__pyx_tuple__1035); + __pyx_codeobj__1036 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1035, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeBestSol, 4599, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1036)) __PYX_ERR(0, 4599, __pyx_L1_error) + __pyx_tuple__1037 = PyTuple_Pack(2, __pyx_kp_u_origprob_sol, Py_False); if (unlikely(!__pyx_tuple__1037)) __PYX_ERR(0, 4599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1037); + __Pyx_GIVEREF(__pyx_tuple__1037); + + /* "src/pyscipopt/scip.pxi":4618 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeBestTransSol(self, filename="transprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the best feasible primal solution for the transformed problem to a file. + * + */ + __pyx_codeobj__1038 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1035, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeBestTransSol, 4618, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1038)) __PYX_ERR(0, 4618, __pyx_L1_error) + __pyx_tuple__1039 = PyTuple_Pack(2, __pyx_kp_u_transprob_sol, Py_False); if (unlikely(!__pyx_tuple__1039)) __PYX_ERR(0, 4618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1039); + __Pyx_GIVEREF(__pyx_tuple__1039); + + /* "src/pyscipopt/scip.pxi":4636 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeSol(self, Solution solution, filename="origprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the given primal solution to a file. + * + */ + __pyx_tuple__1040 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_filename, __pyx_n_s_write_zeros, __pyx_n_s_user_locale, __pyx_n_s_f, __pyx_n_s_cfile); if (unlikely(!__pyx_tuple__1040)) __PYX_ERR(0, 4636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1040); + __Pyx_GIVEREF(__pyx_tuple__1040); + __pyx_codeobj__1041 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1040, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeSol, 4636, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1041)) __PYX_ERR(0, 4636, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4655 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeTransSol(self, Solution solution, filename="transprob.sol", write_zeros=False): # <<<<<<<<<<<<<< + * """Write the given transformed primal solution to a file. + * + */ + __pyx_codeobj__1042 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1040, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeTransSol, 4655, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1042)) __PYX_ERR(0, 4655, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4676 + * # perhaps this should not be included as it implements duplicated functionality + * # (as does it's namesake in SCIP) + * def readSol(self, filename): # <<<<<<<<<<<<<< + * """Reads a given solution file, problem has to be transformed in advance. + * + */ + __pyx_codeobj__1043 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1022, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_readSol, 4676, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1043)) __PYX_ERR(0, 4676, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4690 + * locale.setlocale(locale.LC_NUMERIC, user_locale) + * + * def readSolFile(self, filename): # <<<<<<<<<<<<<< + * """Reads a given solution file. + * + */ + __pyx_tuple__1044 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_partial, __pyx_n_s_error, __pyx_n_s_stored, __pyx_n_s_solution, __pyx_n_s_str_absfile, __pyx_n_s_absfile, __pyx_n_s_user_locale); if (unlikely(!__pyx_tuple__1044)) __PYX_ERR(0, 4690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1044); + __Pyx_GIVEREF(__pyx_tuple__1044); + __pyx_codeobj__1045 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1044, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_readSolFile, 4690, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1045)) __PYX_ERR(0, 4690, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4720 + * return solution + * + * def setSolVal(self, Solution solution, Variable var, val): # <<<<<<<<<<<<<< + * """Set a variable in a solution. + * + */ + __pyx_tuple__1046 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_var, __pyx_n_s_val, __pyx_n_s_sol_2); if (unlikely(!__pyx_tuple__1046)) __PYX_ERR(0, 4720, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1046); + __Pyx_GIVEREF(__pyx_tuple__1046); + __pyx_codeobj__1047 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1046, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setSolVal, 4720, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1047)) __PYX_ERR(0, 4720, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4734 + * PY_SCIP_CALL(SCIPsetSolVal(self._scip, _sol, var.scip_var, val)) + * + * def trySol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, free=True): # <<<<<<<<<<<<<< + * """Check given primal solution for feasibility and try to add it to the storage. + * + */ + __pyx_tuple__1048 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_printreason, __pyx_n_s_completely, __pyx_n_s_checkbounds, __pyx_n_s_checkintegrality, __pyx_n_s_checklprows, __pyx_n_s_free, __pyx_n_s_stored); if (unlikely(!__pyx_tuple__1048)) __PYX_ERR(0, 4734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1048); + __Pyx_GIVEREF(__pyx_tuple__1048); + __pyx_codeobj__1049 = (PyObject*)__Pyx_PyCode_New(8, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1048, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_trySol, 4734, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1049)) __PYX_ERR(0, 4734, __pyx_L1_error) + __pyx_tuple__1050 = PyTuple_Pack(6, Py_True, Py_False, Py_True, Py_True, Py_True, Py_True); if (unlikely(!__pyx_tuple__1050)) __PYX_ERR(0, 4734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1050); + __Pyx_GIVEREF(__pyx_tuple__1050); + + /* "src/pyscipopt/scip.pxi":4753 + * return stored + * + * def checkSol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, original=False): # <<<<<<<<<<<<<< + * """Check given primal solution for feasibility without adding it to the storage. + * + */ + __pyx_tuple__1051 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_printreason, __pyx_n_s_completely, __pyx_n_s_checkbounds, __pyx_n_s_checkintegrality, __pyx_n_s_checklprows, __pyx_n_s_original, __pyx_n_s_feasible); if (unlikely(!__pyx_tuple__1051)) __PYX_ERR(0, 4753, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1051); + __Pyx_GIVEREF(__pyx_tuple__1051); + __pyx_codeobj__1052 = (PyObject*)__Pyx_PyCode_New(8, 0, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1051, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_checkSol, 4753, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1052)) __PYX_ERR(0, 4753, __pyx_L1_error) + __pyx_tuple__1053 = PyTuple_Pack(6, Py_True, Py_False, Py_True, Py_True, Py_True, Py_False); if (unlikely(!__pyx_tuple__1053)) __PYX_ERR(0, 4753, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1053); + __Pyx_GIVEREF(__pyx_tuple__1053); + + /* "src/pyscipopt/scip.pxi":4772 + * return feasible + * + * def addSol(self, Solution solution, free=True): # <<<<<<<<<<<<<< + * """Try to add a solution to the storage. + * + */ + __pyx_tuple__1054 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_solution, __pyx_n_s_free, __pyx_n_s_stored); if (unlikely(!__pyx_tuple__1054)) __PYX_ERR(0, 4772, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1054); + __Pyx_GIVEREF(__pyx_tuple__1054); + __pyx_codeobj__1055 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1054, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_addSol, 4772, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1055)) __PYX_ERR(0, 4772, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4786 + * return stored + * + * def freeSol(self, Solution solution): # <<<<<<<<<<<<<< + * """Free given solution + * + */ + __pyx_codeobj__1056 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__412, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_freeSol, 4786, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1056)) __PYX_ERR(0, 4786, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4794 + * PY_SCIP_CALL(SCIPfreeSol(self._scip, &solution.sol)) + * + * def getNSols(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions stored in the solution storage in case the problem is transformed; + * in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate + */ + __pyx_codeobj__1057 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNSols, 4794, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1057)) __PYX_ERR(0, 4794, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4801 + * return SCIPgetNSols(self._scip) + * + * def getNSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions found so far""" + * return SCIPgetNSolsFound(self._scip) + */ + __pyx_codeobj__1058 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNSolsFound, 4801, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1058)) __PYX_ERR(0, 4801, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4805 + * return SCIPgetNSolsFound(self._scip) + * + * def getNLimSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions respecting the objective limit found so far""" + * return SCIPgetNLimSolsFound(self._scip) + */ + __pyx_codeobj__1059 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNLimSolsFound, 4805, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1059)) __PYX_ERR(0, 4805, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4809 + * return SCIPgetNLimSolsFound(self._scip) + * + * def getNBestSolsFound(self): # <<<<<<<<<<<<<< + * """gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found""" + * return SCIPgetNBestSolsFound(self._scip) + */ + __pyx_codeobj__1060 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNBestSolsFound, 4809, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1060)) __PYX_ERR(0, 4809, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4813 + * return SCIPgetNBestSolsFound(self._scip) + * + * def getSols(self): # <<<<<<<<<<<<<< + * """Retrieve list of all feasible primal solutions stored in the solution storage.""" + * cdef SCIP_SOL** _sols + */ + __pyx_tuple__1061 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_sols, __pyx_n_s_sol_2, __pyx_n_s_nsols, __pyx_n_s_sols_2, __pyx_n_s_i); if (unlikely(!__pyx_tuple__1061)) __PYX_ERR(0, 4813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1061); + __Pyx_GIVEREF(__pyx_tuple__1061); + __pyx_codeobj__1062 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1061, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getSols, 4813, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1062)) __PYX_ERR(0, 4813, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4826 + * return sols + * + * def getBestSol(self): # <<<<<<<<<<<<<< + * """Retrieve currently best known feasible primal solution.""" + * self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip)) + */ + __pyx_codeobj__1063 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getBestSol, 4826, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1063)) __PYX_ERR(0, 4826, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4831 + * return self._bestSol + * + * def getSolObjVal(self, Solution sol, original=True): # <<<<<<<<<<<<<< + * """Retrieve the objective value of the solution. + * + */ + __pyx_tuple__1064 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_sol, __pyx_n_s_original, __pyx_n_s_objval); if (unlikely(!__pyx_tuple__1064)) __PYX_ERR(0, 4831, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1064); + __Pyx_GIVEREF(__pyx_tuple__1064); + __pyx_codeobj__1065 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1064, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getSolObjVal, 4831, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1065)) __PYX_ERR(0, 4831, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4847 + * return objval + * + * def getSolTime(self, Solution sol): # <<<<<<<<<<<<<< + * """Get clock time, when this solution was found. + * + */ + __pyx_tuple__1066 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_sol); if (unlikely(!__pyx_tuple__1066)) __PYX_ERR(0, 4847, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1066); + __Pyx_GIVEREF(__pyx_tuple__1066); + __pyx_codeobj__1067 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1066, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getSolTime, 4847, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1067)) __PYX_ERR(0, 4847, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4855 + * return SCIPgetSolTime(self._scip, sol.sol) + * + * def getObjVal(self, original=True): # <<<<<<<<<<<<<< + * """Retrieve the objective value of value of best solution. + * Can only be called after solving is completed. + */ + __pyx_codeobj__1068 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__670, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getObjVal, 4855, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1068)) __PYX_ERR(0, 4855, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4866 + * return self.getSolObjVal(self._bestSol, original) + * + * def getSolVal(self, Solution sol, Expr expr): # <<<<<<<<<<<<<< + * """Retrieve value of given variable or expression in the given solution or in + * the LP/pseudo solution if sol == None + */ + __pyx_tuple__1069 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_sol, __pyx_n_s_expr, __pyx_n_s_var); if (unlikely(!__pyx_tuple__1069)) __PYX_ERR(0, 4866, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1069); + __Pyx_GIVEREF(__pyx_tuple__1069); + __pyx_codeobj__1070 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1069, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getSolVal, 4866, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1070)) __PYX_ERR(0, 4866, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4883 + * return sol[expr] + * + * def getVal(self, Expr expr): # <<<<<<<<<<<<<< + * """Retrieve the value of the given variable or expression in the best known solution. + * Can only be called after solving is completed. + */ + __pyx_tuple__1071 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_expr); if (unlikely(!__pyx_tuple__1071)) __PYX_ERR(0, 4883, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1071); + __Pyx_GIVEREF(__pyx_tuple__1071); + __pyx_codeobj__1072 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1071, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getVal, 4883, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1072)) __PYX_ERR(0, 4883, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4895 + * return self.getSolVal(self._bestSol, expr) + * + * def hasPrimalRay(self): # <<<<<<<<<<<<<< + * """ + * Returns whether a primal ray is stored that proves unboundedness of the LP relaxation + */ + __pyx_codeobj__1073 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_hasPrimalRay, 4895, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1073)) __PYX_ERR(0, 4895, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4901 + * return SCIPhasPrimalRay(self._scip) + * + * def getPrimalRayVal(self, Variable var): # <<<<<<<<<<<<<< + * """ + * Gets value of given variable in primal ray causing unboundedness of the LP relaxation + */ + __pyx_codeobj__1074 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__479, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getPrimalRayVal, 4901, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1074)) __PYX_ERR(0, 4901, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4909 + * return SCIPgetPrimalRayVal(self._scip, var.scip_var) + * + * def getPrimalRay(self): # <<<<<<<<<<<<<< + * """ + * Gets primal ray causing unboundedness of the LP relaxation + */ + __pyx_tuple__1075 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_nvars_2, __pyx_n_s_vars_2, __pyx_n_s_ray, __pyx_n_s_i); if (unlikely(!__pyx_tuple__1075)) __PYX_ERR(0, 4909, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1075); + __Pyx_GIVEREF(__pyx_tuple__1075); + __pyx_codeobj__1076 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1075, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getPrimalRay, 4909, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1076)) __PYX_ERR(0, 4909, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4924 + * return ray + * + * def getPrimalbound(self): # <<<<<<<<<<<<<< + * """Retrieve the best primal bound.""" + * return SCIPgetPrimalbound(self._scip) + */ + __pyx_codeobj__1077 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getPrimalbound, 4924, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1077)) __PYX_ERR(0, 4924, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4928 + * return SCIPgetPrimalbound(self._scip) + * + * def getDualbound(self): # <<<<<<<<<<<<<< + * """Retrieve the best dual bound.""" + * return SCIPgetDualbound(self._scip) + */ + __pyx_codeobj__1078 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDualbound, 4928, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1078)) __PYX_ERR(0, 4928, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4932 + * return SCIPgetDualbound(self._scip) + * + * def getDualboundRoot(self): # <<<<<<<<<<<<<< + * """Retrieve the best root dual bound.""" + * return SCIPgetDualboundRoot(self._scip) + */ + __pyx_codeobj__1079 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getDualboundRoot, 4932, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1079)) __PYX_ERR(0, 4932, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4936 + * return SCIPgetDualboundRoot(self._scip) + * + * def writeName(self, Variable var): # <<<<<<<<<<<<<< + * """Write the name of the variable to the std out. + * + */ + __pyx_tuple__1080 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_user_locale); if (unlikely(!__pyx_tuple__1080)) __PYX_ERR(0, 4936, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1080); + __Pyx_GIVEREF(__pyx_tuple__1080); + __pyx_codeobj__1081 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1080, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeName, 4936, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1081)) __PYX_ERR(0, 4936, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4949 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getStage(self): # <<<<<<<<<<<<<< + * """Retrieve current SCIP stage""" + * return SCIPgetStage(self._scip) + */ + __pyx_codeobj__1082 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getStage, 4949, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1082)) __PYX_ERR(0, 4949, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4953 + * return SCIPgetStage(self._scip) + * + * def getStageName(self): # <<<<<<<<<<<<<< + * """Returns name of current stage as string""" + * if not StageNames: + */ + __pyx_codeobj__1083 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getStageName, 4953, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1083)) __PYX_ERR(0, 4953, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4959 + * return StageNames[self.getStage()] + * + * def _getStageNames(self): # <<<<<<<<<<<<<< + * """Gets names of stages""" + * for name in dir(PY_SCIP_STAGE): + */ + __pyx_codeobj__1084 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__475, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getStageNames, 4959, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1084)) __PYX_ERR(0, 4959, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":4966 + * StageNames[attr] = name + * + * def getStatus(self): # <<<<<<<<<<<<<< + * """Retrieve solution status.""" + * cdef SCIP_STATUS stat = SCIPgetStatus(self._scip) + */ + __pyx_codeobj__1085 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__488, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getStatus, 4966, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1085)) __PYX_ERR(0, 4966, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5004 + * return "unknown" + * + * def getObjectiveSense(self): # <<<<<<<<<<<<<< + * """Retrieve objective sense.""" + * cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip) + */ + __pyx_tuple__1086 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_sense); if (unlikely(!__pyx_tuple__1086)) __PYX_ERR(0, 5004, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1086); + __Pyx_GIVEREF(__pyx_tuple__1086); + __pyx_codeobj__1087 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1086, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getObjectiveSense, 5004, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1087)) __PYX_ERR(0, 5004, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5014 + * return "unknown" + * + * def catchEvent(self, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches a global (not variable or row dependent) event""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + __pyx_tuple__1088 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_eventtype, __pyx_n_s_eventhdlr, __pyx_n_s_eventhdlr_2, __pyx_n_s_n); if (unlikely(!__pyx_tuple__1088)) __PYX_ERR(0, 5014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1088); + __Pyx_GIVEREF(__pyx_tuple__1088); + __pyx_codeobj__1089 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1088, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_catchEvent, 5014, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1089)) __PYX_ERR(0, 5014, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5026 + * PY_SCIP_CALL(SCIPcatchEvent(self._scip, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropEvent(self, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops a global event (stops to track event)""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + __pyx_codeobj__1090 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1088, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_dropEvent, 5026, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1090)) __PYX_ERR(0, 5026, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5038 + * PY_SCIP_CALL(SCIPdropEvent(self._scip, eventtype, _eventhdlr, NULL, -1)) + * + * def catchVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches an objective value or domain change event on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + __pyx_tuple__1091 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_eventtype, __pyx_n_s_eventhdlr, __pyx_n_s_eventhdlr_2, __pyx_n_s_n); if (unlikely(!__pyx_tuple__1091)) __PYX_ERR(0, 5038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1091); + __Pyx_GIVEREF(__pyx_tuple__1091); + __pyx_codeobj__1092 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1091, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_catchVarEvent, 5038, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1092)) __PYX_ERR(0, 5038, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5048 + * PY_SCIP_CALL(SCIPcatchVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops an objective value or domain change event (stops to track event) on the given transformed variable""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + __pyx_codeobj__1093 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1091, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_dropVarEvent, 5048, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1093)) __PYX_ERR(0, 5048, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5058 + * PY_SCIP_CALL(SCIPdropVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, -1)) + * + * def catchRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """catches a row coefficient, constant, or side change event on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + __pyx_tuple__1094 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_row, __pyx_n_s_eventtype, __pyx_n_s_eventhdlr, __pyx_n_s_eventhdlr_2, __pyx_n_s_n); if (unlikely(!__pyx_tuple__1094)) __PYX_ERR(0, 5058, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1094); + __Pyx_GIVEREF(__pyx_tuple__1094); + __pyx_codeobj__1095 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1094, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_catchRowEvent, 5058, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1095)) __PYX_ERR(0, 5058, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5068 + * PY_SCIP_CALL(SCIPcatchRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, NULL)) + * + * def dropRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr): # <<<<<<<<<<<<<< + * """drops a row coefficient, constant, or side change event (stops to track event) on the given row""" + * cdef SCIP_EVENTHDLR* _eventhdlr + */ + __pyx_codeobj__1096 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1094, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_dropRowEvent, 5068, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1096)) __PYX_ERR(0, 5068, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5080 + * # Statistic Methods + * + * def printStatistics(self): # <<<<<<<<<<<<<< + * """Print statistics.""" + * user_locale = locale.getlocale(category=locale.LC_NUMERIC) + */ + __pyx_codeobj__1097 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__614, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_printStatistics, 5080, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1097)) __PYX_ERR(0, 5080, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5089 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def writeStatistics(self, filename="origprob.stats"): # <<<<<<<<<<<<<< + * """Write statistics to a file. + * + */ + __pyx_tuple__1098 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_user_locale, __pyx_n_s_f, __pyx_n_s_cfile); if (unlikely(!__pyx_tuple__1098)) __PYX_ERR(0, 5089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1098); + __Pyx_GIVEREF(__pyx_tuple__1098); + __pyx_codeobj__1099 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1098, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeStatistics, 5089, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1099)) __PYX_ERR(0, 5089, __pyx_L1_error) + __pyx_tuple__1100 = PyTuple_Pack(1, __pyx_kp_u_origprob_stats); if (unlikely(!__pyx_tuple__1100)) __PYX_ERR(0, 5089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1100); + __Pyx_GIVEREF(__pyx_tuple__1100); + + /* "src/pyscipopt/scip.pxi":5106 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def getNLPs(self): # <<<<<<<<<<<<<< + * """gets total number of LPs solved so far""" + * return SCIPgetNLPs(self._scip) + */ + __pyx_codeobj__1101 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNLPs, 5106, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1101)) __PYX_ERR(0, 5106, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5112 + * # Verbosity Methods + * + * def hideOutput(self, quiet = True): # <<<<<<<<<<<<<< + * """Hide the output. + * + */ + __pyx_tuple__1102 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_quiet); if (unlikely(!__pyx_tuple__1102)) __PYX_ERR(0, 5112, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1102); + __Pyx_GIVEREF(__pyx_tuple__1102); + __pyx_codeobj__1103 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1102, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_hideOutput, 5112, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1103)) __PYX_ERR(0, 5112, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5122 + * # Output Methods + * + * def redirectOutput(self): # <<<<<<<<<<<<<< + * """Send output to python instead of terminal.""" + * + */ + __pyx_tuple__1104 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_myMessageHandler); if (unlikely(!__pyx_tuple__1104)) __PYX_ERR(0, 5122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1104); + __Pyx_GIVEREF(__pyx_tuple__1104); + __pyx_codeobj__1105 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1104, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_redirectOutput, 5122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1105)) __PYX_ERR(0, 5122, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5131 + * SCIPmessageSetErrorPrinting(relayErrorMessage, NULL) + * + * def setLogfile(self, path): # <<<<<<<<<<<<<< + * """sets the log file name for the currently installed message handler + * :param path: name of log file, or None (no log) + */ + __pyx_tuple__1106 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_path, __pyx_n_s_c_path); if (unlikely(!__pyx_tuple__1106)) __PYX_ERR(0, 5131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1106); + __Pyx_GIVEREF(__pyx_tuple__1106); + __pyx_codeobj__1107 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1106, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setLogfile, 5131, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1107)) __PYX_ERR(0, 5131, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5143 + * # Parameter Methods + * + * def setBoolParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a boolean-valued parameter. + * + */ + __pyx_tuple__1108 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_n); if (unlikely(!__pyx_tuple__1108)) __PYX_ERR(0, 5143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1108); + __Pyx_GIVEREF(__pyx_tuple__1108); + __pyx_codeobj__1109 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1108, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setBoolParam, 5143, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1109)) __PYX_ERR(0, 5143, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5153 + * PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, value)) + * + * def setIntParam(self, name, value): # <<<<<<<<<<<<<< + * """Set an int-valued parameter. + * + */ + __pyx_codeobj__1110 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1108, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setIntParam, 5153, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1110)) __PYX_ERR(0, 5153, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5163 + * PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, value)) + * + * def setLongintParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a long-valued parameter. + * + */ + __pyx_codeobj__1111 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1108, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setLongintParam, 5163, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1111)) __PYX_ERR(0, 5163, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5173 + * PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, value)) + * + * def setRealParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a real-valued parameter. + * + */ + __pyx_codeobj__1112 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1108, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setRealParam, 5173, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1112)) __PYX_ERR(0, 5173, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5183 + * PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, value)) + * + * def setCharParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a char-valued parameter. + * + */ + __pyx_codeobj__1113 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1108, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setCharParam, 5183, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1113)) __PYX_ERR(0, 5183, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5193 + * PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value))) + * + * def setStringParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a string-valued parameter. + * + */ + __pyx_tuple__1114 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_n, __pyx_n_s_v); if (unlikely(!__pyx_tuple__1114)) __PYX_ERR(0, 5193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1114); + __Pyx_GIVEREF(__pyx_tuple__1114); + __pyx_codeobj__1115 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1114, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setStringParam, 5193, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1115)) __PYX_ERR(0, 5193, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5204 + * PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v)) + * + * def setParam(self, name, value): # <<<<<<<<<<<<<< + * """Set a parameter with value in int, bool, real, long, char or str. + * + */ + __pyx_tuple__1116 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_param, __pyx_n_s_n, __pyx_n_s_paramtype, __pyx_n_s_v); if (unlikely(!__pyx_tuple__1116)) __PYX_ERR(0, 5204, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1116); + __Pyx_GIVEREF(__pyx_tuple__1116); + __pyx_codeobj__1117 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1116, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setParam, 5204, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1117)) __PYX_ERR(0, 5204, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5235 + * + * + * def getParam(self, name): # <<<<<<<<<<<<<< + * """Get the value of a parameter of type + * int, bool, real, long, char or str. + */ + __pyx_tuple__1118 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_param, __pyx_n_s_n, __pyx_n_s_paramtype); if (unlikely(!__pyx_tuple__1118)) __PYX_ERR(0, 5235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1118); + __Pyx_GIVEREF(__pyx_tuple__1118); + __pyx_codeobj__1119 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1118, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getParam, 5235, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1119)) __PYX_ERR(0, 5235, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5264 + * return SCIPparamGetString(param).decode('utf-8') + * + * def getParams(self): # <<<<<<<<<<<<<< + * """Gets the values of all parameters as a dict mapping parameter names + * to their values.""" + */ + __pyx_tuple__1120 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_params, __pyx_n_s_result, __pyx_n_s_i, __pyx_n_s_name); if (unlikely(!__pyx_tuple__1120)) __PYX_ERR(0, 5264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1120); + __Pyx_GIVEREF(__pyx_tuple__1120); + __pyx_codeobj__1121 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1120, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getParams, 5264, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1121)) __PYX_ERR(0, 5264, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5276 + * return result + * + * def setParams(self, params): # <<<<<<<<<<<<<< + * """Sets multiple parameters at once. + * + */ + __pyx_tuple__1122 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_params, __pyx_n_s_name, __pyx_n_s_value); if (unlikely(!__pyx_tuple__1122)) __PYX_ERR(0, 5276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1122); + __Pyx_GIVEREF(__pyx_tuple__1122); + __pyx_codeobj__1123 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1122, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setParams, 5276, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1123)) __PYX_ERR(0, 5276, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5284 + * self.setParam(name, value) + * + * def readParams(self, file): # <<<<<<<<<<<<<< + * """Read an external parameter file. + * + */ + __pyx_tuple__1124 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_file, __pyx_n_s_absfile, __pyx_n_s_user_locale); if (unlikely(!__pyx_tuple__1124)) __PYX_ERR(0, 5284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1124); + __Pyx_GIVEREF(__pyx_tuple__1124); + __pyx_codeobj__1125 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1124, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_readParams, 5284, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1125)) __PYX_ERR(0, 5284, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5299 + * locale.setlocale(locale.LC_NUMERIC, user_locale) + * + * def writeParams(self, filename='param.set', comments=True, onlychanged=True, verbose=True): # <<<<<<<<<<<<<< + * """Write parameter settings to an external file. + * + */ + __pyx_tuple__1126 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_comments, __pyx_n_s_onlychanged, __pyx_n_s_verbose, __pyx_n_s_user_locale, __pyx_n_s_str_absfile, __pyx_n_s_absfile); if (unlikely(!__pyx_tuple__1126)) __PYX_ERR(0, 5299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1126); + __Pyx_GIVEREF(__pyx_tuple__1126); + __pyx_codeobj__1127 = (PyObject*)__Pyx_PyCode_New(5, 0, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1126, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_writeParams, 5299, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1127)) __PYX_ERR(0, 5299, __pyx_L1_error) + __pyx_tuple__1128 = PyTuple_Pack(4, __pyx_kp_u_param_set, Py_True, Py_True, Py_True); if (unlikely(!__pyx_tuple__1128)) __PYX_ERR(0, 5299, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1128); + __Pyx_GIVEREF(__pyx_tuple__1128); + + /* "src/pyscipopt/scip.pxi":5319 + * locale.setlocale(locale.LC_NUMERIC,user_locale) + * + * def resetParam(self, name): # <<<<<<<<<<<<<< + * """Reset parameter setting to its default value + * + */ + __pyx_codeobj__1129 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__676, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_resetParam, 5319, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1129)) __PYX_ERR(0, 5319, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5328 + * PY_SCIP_CALL(SCIPresetParam(self._scip, n)) + * + * def resetParams(self): # <<<<<<<<<<<<<< + * """Reset parameter settings to their default values""" + * PY_SCIP_CALL(SCIPresetParams(self._scip)) + */ + __pyx_codeobj__1130 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_resetParams, 5328, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1130)) __PYX_ERR(0, 5328, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5332 + * PY_SCIP_CALL(SCIPresetParams(self._scip)) + * + * def setEmphasis(self, paraemphasis, quiet = True): # <<<<<<<<<<<<<< + * """Set emphasis settings + * + */ + __pyx_tuple__1131 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_paraemphasis, __pyx_n_s_quiet); if (unlikely(!__pyx_tuple__1131)) __PYX_ERR(0, 5332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1131); + __Pyx_GIVEREF(__pyx_tuple__1131); + __pyx_codeobj__1132 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1131, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setEmphasis, 5332, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1132)) __PYX_ERR(0, 5332, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5341 + * PY_SCIP_CALL(SCIPsetEmphasis(self._scip, paraemphasis, quiet)) + * + * def readProblem(self, filename, extension = None): # <<<<<<<<<<<<<< + * """Read a problem instance from an external file. + * + */ + __pyx_tuple__1133 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_extension, __pyx_n_s_user_locale, __pyx_n_s_absfile); if (unlikely(!__pyx_tuple__1133)) __PYX_ERR(0, 5341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1133); + __Pyx_GIVEREF(__pyx_tuple__1133); + __pyx_codeobj__1134 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1133, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_readProblem, 5341, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1134)) __PYX_ERR(0, 5341, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5362 + * # Counting functions + * + * def count(self): # <<<<<<<<<<<<<< + * """Counts the number of feasible points of problem.""" + * PY_SCIP_CALL(SCIPcount(self._scip)) + */ + __pyx_codeobj__1135 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_count, 5362, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1135)) __PYX_ERR(0, 5362, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5366 + * PY_SCIP_CALL(SCIPcount(self._scip)) + * + * def getNReaders(self): # <<<<<<<<<<<<<< + * """Get number of currently available readers.""" + * return SCIPgetNReaders(self._scip) + */ + __pyx_codeobj__1136 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNReaders, 5366, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1136)) __PYX_ERR(0, 5366, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5370 + * return SCIPgetNReaders(self._scip) + * + * def getNCountedSols(self): # <<<<<<<<<<<<<< + * """Get number of feasible solution.""" + * cdef SCIP_Bool valid + */ + __pyx_tuple__1137 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_valid, __pyx_n_s_nsols); if (unlikely(!__pyx_tuple__1137)) __PYX_ERR(0, 5370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1137); + __Pyx_GIVEREF(__pyx_tuple__1137); + __pyx_codeobj__1138 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1137, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getNCountedSols, 5370, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1138)) __PYX_ERR(0, 5370, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5380 + * return nsols + * + * def setParamsCountsols(self): # <<<<<<<<<<<<<< + * """Sets SCIP parameters such that a valid counting process is possible.""" + * PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip)) + */ + __pyx_codeobj__1139 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_setParamsCountsols, 5380, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1139)) __PYX_ERR(0, 5380, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5384 + * PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip)) + * + * def freeReoptSolve(self): # <<<<<<<<<<<<<< + * """Frees all solution process data and prepares for reoptimization""" + * PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip)) + */ + __pyx_codeobj__1140 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_freeReoptSolve, 5384, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1140)) __PYX_ERR(0, 5384, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5388 + * PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip)) + * + * def chgReoptObjective(self, coeffs, sense = 'minimize'): # <<<<<<<<<<<<<< + * """Establish the objective function as a linear expression. + * + */ + __pyx_tuple__1141 = PyTuple_Pack(11, __pyx_n_s_self, __pyx_n_s_coeffs, __pyx_n_s_sense, __pyx_n_s_objsense, __pyx_n_s_vars_2, __pyx_n_s_nvars_2, __pyx_n_s_coeffs_2, __pyx_n_s_i, __pyx_n_s_term, __pyx_n_s_coef, __pyx_n_s_var); if (unlikely(!__pyx_tuple__1141)) __PYX_ERR(0, 5388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1141); + __Pyx_GIVEREF(__pyx_tuple__1141); + __pyx_codeobj__1142 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1141, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgReoptObjective, 5388, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1142)) __PYX_ERR(0, 5388, __pyx_L1_error) + __pyx_tuple__1143 = PyTuple_Pack(1, __pyx_n_u_minimize); if (unlikely(!__pyx_tuple__1143)) __PYX_ERR(0, 5388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1143); + __Pyx_GIVEREF(__pyx_tuple__1143); + + /* "src/pyscipopt/scip.pxi":5434 + * free(_coeffs) + * + * def chgVarBranchPriority(self, Variable var, priority): # <<<<<<<<<<<<<< + * """Sets the branch priority of the variable. + * Variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable. + */ + __pyx_tuple__1144 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_var, __pyx_n_s_priority); if (unlikely(!__pyx_tuple__1144)) __PYX_ERR(0, 5434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1144); + __Pyx_GIVEREF(__pyx_tuple__1144); + __pyx_codeobj__1145 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1144, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_chgVarBranchPriority, 5434, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1145)) __PYX_ERR(0, 5434, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5444 + * PY_SCIP_CALL(SCIPchgVarBranchPriority(self._scip, var.scip_var, priority)) + * + * def getTreesizeEstimation(self): # <<<<<<<<<<<<<< + * """Get an estimation of the final tree size """ + * return SCIPgetTreesizeEstimation(self._scip) + */ + __pyx_codeobj__1146 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_getTreesizeEstimation, 5444, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1146)) __PYX_ERR(0, 5444, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__1147 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__136, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1147)) __PYX_ERR(6, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__1148 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1148)) __PYX_ERR(6, 3, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5449 + * + * # debugging memory management + * def is_memory_freed(): # <<<<<<<<<<<<<< + * return BMSgetMemoryUsed() == 0 + * + */ + __pyx_codeobj__1149 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_is_memory_freed, 5449, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1149)) __PYX_ERR(0, 5449, __pyx_L1_error) + + /* "src/pyscipopt/scip.pxi":5452 + * return BMSgetMemoryUsed() == 0 + * + * def print_memory_in_use(): # <<<<<<<<<<<<<< + * BMScheckEmptyMemory() + */ + __pyx_codeobj__1150 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyscipopt_scip_pxi, __pyx_n_s_print_memory_in_use, 5452, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1150)) __PYX_ERR(0, 5452, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __pyx_unpickle_Expr(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__1151 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__1151)) __PYX_ERR(6, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__1151); + __Pyx_GIVEREF(__pyx_tuple__1151); + __pyx_codeobj__1152 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Expr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1152)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1153 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_ExprCons, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1153)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1154 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_GenExpr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1154)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1155 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_SumExpr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1155)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1156 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_ProdExpr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1156)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1157 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_VarExpr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1157)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1158 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PowExpr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1158)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1159 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_UnaryExpr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1159)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1160 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Constant, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1160)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1161 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Benderscut, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1161)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1162 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Branchrule, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1162)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1163 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Conshdlr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1163)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1164 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Cutsel, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1164)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1165 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Eventhdlr, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1165)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1166 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Heur, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1166)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1167 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Presol, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1167)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1168 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Pricer, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1168)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1169 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Prop, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1169)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1170 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Sepa, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1170)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1171 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Reader, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1171)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1172 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Relax, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1172)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1173 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Nodesel, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1173)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1174 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_RESULT, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1174)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1175 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1175)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1176 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1176)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1177 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_STATUS, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1177)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1178 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_STAGE, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1178)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1179 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1179)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1180 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1180)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1181 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1181)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1182 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1182)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1183 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1183)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1184 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1184)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1185 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1185)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1186 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1186)) __PYX_ERR(6, 1, __pyx_L1_error) + __pyx_codeobj__1187 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__1151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__1187)) __PYX_ERR(6, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + __pyx_umethod_PyDict_Type_get.type = (PyObject*)&PyDict_Type; + __pyx_umethod_PyDict_Type_get.method_name = &__pyx_n_s_get; + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(5, 1, __pyx_L1_error); + __pyx_float_0_0 = PyFloat_FromDouble(0.0); if (unlikely(!__pyx_float_0_0)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_float_1_0)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_float_10_0 = PyFloat_FromDouble(10.0); if (unlikely(!__pyx_float_10_0)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_float_100_0 = PyFloat_FromDouble(100.0); if (unlikely(!__pyx_float_100_0)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_float_1e_20 = PyFloat_FromDouble(1e+20); if (unlikely(!__pyx_float_1e_20)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_float_neg_1_0 = PyFloat_FromDouble(-1.0); if (unlikely(!__pyx_float_neg_1_0)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_9 = PyInt_FromLong(9); if (unlikely(!__pyx_int_9)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_101 = PyInt_FromLong(101); if (unlikely(!__pyx_int_101)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_10000 = PyInt_FromLong(10000L); if (unlikely(!__pyx_int_10000)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_13758880 = PyInt_FromLong(13758880L); if (unlikely(!__pyx_int_13758880)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_25280761 = PyInt_FromLong(25280761L); if (unlikely(!__pyx_int_25280761)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_30435853 = PyInt_FromLong(30435853L); if (unlikely(!__pyx_int_30435853)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_34551270 = PyInt_FromLong(34551270L); if (unlikely(!__pyx_int_34551270)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_37557029 = PyInt_FromLong(37557029L); if (unlikely(!__pyx_int_37557029)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_63254455 = PyInt_FromLong(63254455L); if (unlikely(!__pyx_int_63254455)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_76513566 = PyInt_FromLong(76513566L); if (unlikely(!__pyx_int_76513566)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_76998962 = PyInt_FromLong(76998962L); if (unlikely(!__pyx_int_76998962)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_80720285 = PyInt_FromLong(80720285L); if (unlikely(!__pyx_int_80720285)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_85795681 = PyInt_FromLong(85795681L); if (unlikely(!__pyx_int_85795681)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_95355963 = PyInt_FromLong(95355963L); if (unlikely(!__pyx_int_95355963)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_114651189 = PyInt_FromLong(114651189L); if (unlikely(!__pyx_int_114651189)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_116691903 = PyInt_FromLong(116691903L); if (unlikely(!__pyx_int_116691903)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_132603380 = PyInt_FromLong(132603380L); if (unlikely(!__pyx_int_132603380)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_135158539 = PyInt_FromLong(135158539L); if (unlikely(!__pyx_int_135158539)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_143015212 = PyInt_FromLong(143015212L); if (unlikely(!__pyx_int_143015212)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_147635180 = PyInt_FromLong(147635180L); if (unlikely(!__pyx_int_147635180)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_150239579 = PyInt_FromLong(150239579L); if (unlikely(!__pyx_int_150239579)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_152146234 = PyInt_FromLong(152146234L); if (unlikely(!__pyx_int_152146234)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_154610759 = PyInt_FromLong(154610759L); if (unlikely(!__pyx_int_154610759)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_169888372 = PyInt_FromLong(169888372L); if (unlikely(!__pyx_int_169888372)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_173957064 = PyInt_FromLong(173957064L); if (unlikely(!__pyx_int_173957064)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_176834982 = PyInt_FromLong(176834982L); if (unlikely(!__pyx_int_176834982)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_201230365 = PyInt_FromLong(201230365L); if (unlikely(!__pyx_int_201230365)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_204489503 = PyInt_FromLong(204489503L); if (unlikely(!__pyx_int_204489503)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_208012509 = PyInt_FromLong(208012509L); if (unlikely(!__pyx_int_208012509)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_208195651 = PyInt_FromLong(208195651L); if (unlikely(!__pyx_int_208195651)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_214626690 = PyInt_FromLong(214626690L); if (unlikely(!__pyx_int_214626690)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_216408278 = PyInt_FromLong(216408278L); if (unlikely(!__pyx_int_216408278)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_222419149 = PyInt_FromLong(222419149L); if (unlikely(!__pyx_int_222419149)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_228825662 = PyInt_FromLong(228825662L); if (unlikely(!__pyx_int_228825662)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_238750788 = PyInt_FromLong(238750788L); if (unlikely(!__pyx_int_238750788)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_240430858 = PyInt_FromLong(240430858L); if (unlikely(!__pyx_int_240430858)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_248330301 = PyInt_FromLong(248330301L); if (unlikely(!__pyx_int_248330301)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_253686829 = PyInt_FromLong(253686829L); if (unlikely(!__pyx_int_253686829)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_267356384 = PyInt_FromLong(267356384L); if (unlikely(!__pyx_int_267356384)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(5, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_globals ### */ + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + /* AssertionsEnabled.init */ + if (likely(__Pyx_init_assertions_enabled() == 0)); else + +if (unlikely(PyErr_Occurred())) __PYX_ERR(5, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_module ### */ + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Expr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Expr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Expr)) __PYX_ERR(1, 144, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Expr_spec, __pyx_ptype_9pyscipopt_4scip_Expr) < 0) __PYX_ERR(1, 144, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Expr = &__pyx_type_9pyscipopt_4scip_Expr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Expr) < 0) __PYX_ERR(1, 144, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Expr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Expr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Expr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Expr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + #if CYTHON_UPDATE_DESCRIPTOR_DOC + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 144, __pyx_L1_error) + if (__Pyx_IS_TYPE(wrapper, &PyWrapperDescr_Type)) { + __pyx_wrapperbase_9pyscipopt_4scip_4Expr___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_9pyscipopt_4scip_4Expr___init__.doc = __pyx_doc_9pyscipopt_4scip_4Expr___init__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pyscipopt_4scip_4Expr___init__; + } + } + #endif + #if CYTHON_UPDATE_DESCRIPTOR_DOC + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr, "__rtruediv__"); if (unlikely(!wrapper)) __PYX_ERR(1, 144, __pyx_L1_error) + if (__Pyx_IS_TYPE(wrapper, &PyWrapperDescr_Type)) { + __pyx_wrapperbase_9pyscipopt_4scip_4Expr_18__rtruediv__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_9pyscipopt_4scip_4Expr_18__rtruediv__.doc = __pyx_doc_9pyscipopt_4scip_4Expr_18__rtruediv__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pyscipopt_4scip_4Expr_18__rtruediv__; + } + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Expr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Expr) < 0) __PYX_ERR(1, 144, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Expr) < 0) __PYX_ERR(1, 144, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_Event = &__pyx_vtable_9pyscipopt_4scip_Event; + __pyx_vtable_9pyscipopt_4scip_Event.create = (PyObject *(*)(SCIP_EVENT *))__pyx_f_9pyscipopt_4scip_5Event_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Event = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Event_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Event)) __PYX_ERR(0, 301, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Event_spec, __pyx_ptype_9pyscipopt_4scip_Event) < 0) __PYX_ERR(0, 301, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Event = &__pyx_type_9pyscipopt_4scip_Event; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Event) < 0) __PYX_ERR(0, 301, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Event->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Event->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Event->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Event->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_Event, __pyx_vtabptr_9pyscipopt_4scip_Event) < 0) __PYX_ERR(0, 301, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_Event) < 0) __PYX_ERR(0, 301, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Event, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Event) < 0) __PYX_ERR(0, 301, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Event) < 0) __PYX_ERR(0, 301, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_Column = &__pyx_vtable_9pyscipopt_4scip_Column; + __pyx_vtable_9pyscipopt_4scip_Column.create = (PyObject *(*)(SCIP_COL *))__pyx_f_9pyscipopt_4scip_6Column_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Column = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Column_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Column)) __PYX_ERR(0, 365, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Column_spec, __pyx_ptype_9pyscipopt_4scip_Column) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Column = &__pyx_type_9pyscipopt_4scip_Column; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Column) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Column->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Column->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Column->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Column->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_Column, __pyx_vtabptr_9pyscipopt_4scip_Column) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_Column) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Column, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Column) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Column) < 0) __PYX_ERR(0, 365, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_Row = &__pyx_vtable_9pyscipopt_4scip_Row; + __pyx_vtable_9pyscipopt_4scip_Row.create = (PyObject *(*)(SCIP_ROW *))__pyx_f_9pyscipopt_4scip_3Row_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Row = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Row_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Row)) __PYX_ERR(0, 426, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Row_spec, __pyx_ptype_9pyscipopt_4scip_Row) < 0) __PYX_ERR(0, 426, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Row = &__pyx_type_9pyscipopt_4scip_Row; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Row) < 0) __PYX_ERR(0, 426, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Row->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Row->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Row->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Row->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_Row, __pyx_vtabptr_9pyscipopt_4scip_Row) < 0) __PYX_ERR(0, 426, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_Row) < 0) __PYX_ERR(0, 426, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Row, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Row) < 0) __PYX_ERR(0, 426, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Row) < 0) __PYX_ERR(0, 426, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_NLRow = &__pyx_vtable_9pyscipopt_4scip_NLRow; + __pyx_vtable_9pyscipopt_4scip_NLRow.create = (PyObject *(*)(SCIP_NLROW *))__pyx_f_9pyscipopt_4scip_5NLRow_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_NLRow = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_NLRow_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_NLRow)) __PYX_ERR(0, 531, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_NLRow_spec, __pyx_ptype_9pyscipopt_4scip_NLRow) < 0) __PYX_ERR(0, 531, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_NLRow = &__pyx_type_9pyscipopt_4scip_NLRow; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_NLRow) < 0) __PYX_ERR(0, 531, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_NLRow->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_NLRow->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_NLRow->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_NLRow->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_NLRow, __pyx_vtabptr_9pyscipopt_4scip_NLRow) < 0) __PYX_ERR(0, 531, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_NLRow) < 0) __PYX_ERR(0, 531, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_NLRow, (PyObject *) __pyx_ptype_9pyscipopt_4scip_NLRow) < 0) __PYX_ERR(0, 531, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_NLRow) < 0) __PYX_ERR(0, 531, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_Solution = &__pyx_vtable_9pyscipopt_4scip_Solution; + __pyx_vtable_9pyscipopt_4scip_Solution.create = (PyObject *(*)(SCIP *, SCIP_SOL *))__pyx_f_9pyscipopt_4scip_8Solution_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Solution = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Solution_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Solution)) __PYX_ERR(0, 577, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Solution_spec, __pyx_ptype_9pyscipopt_4scip_Solution) < 0) __PYX_ERR(0, 577, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Solution = &__pyx_type_9pyscipopt_4scip_Solution; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Solution) < 0) __PYX_ERR(0, 577, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Solution->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Solution->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Solution->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Solution->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_Solution, __pyx_vtabptr_9pyscipopt_4scip_Solution) < 0) __PYX_ERR(0, 577, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_Solution) < 0) __PYX_ERR(0, 577, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Solution, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Solution) < 0) __PYX_ERR(0, 577, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Solution) < 0) __PYX_ERR(0, 577, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_DomainChanges = &__pyx_vtable_9pyscipopt_4scip_DomainChanges; + __pyx_vtable_9pyscipopt_4scip_DomainChanges.create = (PyObject *(*)(SCIP_DOMCHG *))__pyx_f_9pyscipopt_4scip_13DomainChanges_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_DomainChanges = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_DomainChanges_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_DomainChanges)) __PYX_ERR(0, 669, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_DomainChanges_spec, __pyx_ptype_9pyscipopt_4scip_DomainChanges) < 0) __PYX_ERR(0, 669, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_DomainChanges = &__pyx_type_9pyscipopt_4scip_DomainChanges; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_DomainChanges) < 0) __PYX_ERR(0, 669, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_DomainChanges->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_DomainChanges->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_DomainChanges->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_DomainChanges->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_DomainChanges, __pyx_vtabptr_9pyscipopt_4scip_DomainChanges) < 0) __PYX_ERR(0, 669, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_DomainChanges) < 0) __PYX_ERR(0, 669, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_DomainChanges, (PyObject *) __pyx_ptype_9pyscipopt_4scip_DomainChanges) < 0) __PYX_ERR(0, 669, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_DomainChanges) < 0) __PYX_ERR(0, 669, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_BoundChange = &__pyx_vtable_9pyscipopt_4scip_BoundChange; + __pyx_vtable_9pyscipopt_4scip_BoundChange.create = (PyObject *(*)(SCIP_BOUNDCHG *))__pyx_f_9pyscipopt_4scip_11BoundChange_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_BoundChange = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_BoundChange_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_BoundChange)) __PYX_ERR(0, 633, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_BoundChange_spec, __pyx_ptype_9pyscipopt_4scip_BoundChange) < 0) __PYX_ERR(0, 633, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_BoundChange = &__pyx_type_9pyscipopt_4scip_BoundChange; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_BoundChange) < 0) __PYX_ERR(0, 633, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_BoundChange->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_BoundChange->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_BoundChange->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_BoundChange->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_BoundChange, __pyx_vtabptr_9pyscipopt_4scip_BoundChange) < 0) __PYX_ERR(0, 633, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_BoundChange) < 0) __PYX_ERR(0, 633, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_BoundChange, (PyObject *) __pyx_ptype_9pyscipopt_4scip_BoundChange) < 0) __PYX_ERR(0, 633, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_BoundChange) < 0) __PYX_ERR(0, 633, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_Node = &__pyx_vtable_9pyscipopt_4scip_Node; + __pyx_vtable_9pyscipopt_4scip_Node.create = (PyObject *(*)(SCIP_NODE *))__pyx_f_9pyscipopt_4scip_4Node_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Node = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Node_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Node)) __PYX_ERR(0, 686, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Node_spec, __pyx_ptype_9pyscipopt_4scip_Node) < 0) __PYX_ERR(0, 686, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Node = &__pyx_type_9pyscipopt_4scip_Node; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Node) < 0) __PYX_ERR(0, 686, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Node->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Node->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Node->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Node->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_Node, __pyx_vtabptr_9pyscipopt_4scip_Node) < 0) __PYX_ERR(0, 686, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_Node) < 0) __PYX_ERR(0, 686, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Node, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Node) < 0) __PYX_ERR(0, 686, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Node) < 0) __PYX_ERR(0, 686, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_Variable = &__pyx_vtable_9pyscipopt_4scip_Variable; + __pyx_vtable_9pyscipopt_4scip_Variable.create = (PyObject *(*)(SCIP_VAR *))__pyx_f_9pyscipopt_4scip_8Variable_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_9pyscipopt_4scip_Variable = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Variable_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Variable)) __PYX_ERR(0, 804, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Variable_spec, __pyx_ptype_9pyscipopt_4scip_Variable) < 0) __PYX_ERR(0, 804, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Variable = &__pyx_type_9pyscipopt_4scip_Variable; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_9pyscipopt_4scip_Variable->tp_base = __pyx_ptype_9pyscipopt_4scip_Expr; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Variable) < 0) __PYX_ERR(0, 804, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Variable->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Variable->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Variable->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Variable->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_vtabptr_9pyscipopt_4scip_Variable) < 0) __PYX_ERR(0, 804, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_Variable) < 0) __PYX_ERR(0, 804, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Variable, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Variable) < 0) __PYX_ERR(0, 804, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Variable) < 0) __PYX_ERR(0, 804, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_Constraint = &__pyx_vtable_9pyscipopt_4scip_Constraint; + __pyx_vtable_9pyscipopt_4scip_Constraint.create = (PyObject *(*)(SCIP_CONS *))__pyx_f_9pyscipopt_4scip_10Constraint_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Constraint = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Constraint_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Constraint)) __PYX_ERR(0, 891, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Constraint_spec, __pyx_ptype_9pyscipopt_4scip_Constraint) < 0) __PYX_ERR(0, 891, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Constraint = &__pyx_type_9pyscipopt_4scip_Constraint; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Constraint) < 0) __PYX_ERR(0, 891, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Constraint->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Constraint->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Constraint->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Constraint->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_vtabptr_9pyscipopt_4scip_Constraint) < 0) __PYX_ERR(0, 891, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_Constraint) < 0) __PYX_ERR(0, 891, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Constraint, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Constraint) < 0) __PYX_ERR(0, 891, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Constraint) < 0) __PYX_ERR(0, 891, __pyx_L1_error) + #endif + __pyx_vtabptr_9pyscipopt_4scip_Model = &__pyx_vtable_9pyscipopt_4scip_Model; + __pyx_vtable_9pyscipopt_4scip_Model.create = (PyObject *(*)(SCIP *))__pyx_f_9pyscipopt_4scip_5Model_create; + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Model = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Model_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Model)) __PYX_ERR(0, 993, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Model_spec, __pyx_ptype_9pyscipopt_4scip_Model) < 0) __PYX_ERR(0, 993, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Model = &__pyx_type_9pyscipopt_4scip_Model; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Model) < 0) __PYX_ERR(0, 993, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Model->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Model->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Model->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Model->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + #if CYTHON_UPDATE_DESCRIPTOR_DOC + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 993, __pyx_L1_error) + if (__Pyx_IS_TYPE(wrapper, &PyWrapperDescr_Type)) { + __pyx_wrapperbase_9pyscipopt_4scip_5Model___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_9pyscipopt_4scip_5Model___init__.doc = __pyx_doc_9pyscipopt_4scip_5Model___init__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pyscipopt_4scip_5Model___init__; + } + } + #endif + if (__Pyx_SetVtable(__pyx_ptype_9pyscipopt_4scip_Model, __pyx_vtabptr_9pyscipopt_4scip_Model) < 0) __PYX_ERR(0, 993, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_MergeVtables(__pyx_ptype_9pyscipopt_4scip_Model) < 0) __PYX_ERR(0, 993, __pyx_L1_error) + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Model, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Model) < 0) __PYX_ERR(0, 993, __pyx_L1_error) + if (__pyx_ptype_9pyscipopt_4scip_Model->tp_weaklistoffset == 0) __pyx_ptype_9pyscipopt_4scip_Model->tp_weaklistoffset = offsetof(struct __pyx_obj_9pyscipopt_4scip_Model, __weakref__); + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Model) < 0) __PYX_ERR(0, 993, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_ExprCons = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_ExprCons_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_ExprCons)) __PYX_ERR(1, 287, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_ExprCons_spec, __pyx_ptype_9pyscipopt_4scip_ExprCons) < 0) __PYX_ERR(1, 287, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_ExprCons = &__pyx_type_9pyscipopt_4scip_ExprCons; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_ExprCons) < 0) __PYX_ERR(1, 287, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_ExprCons->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_ExprCons->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_ExprCons->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_ExprCons->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ExprCons_2, (PyObject *) __pyx_ptype_9pyscipopt_4scip_ExprCons) < 0) __PYX_ERR(1, 287, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_ExprCons) < 0) __PYX_ERR(1, 287, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_GenExpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_GenExpr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_GenExpr)) __PYX_ERR(1, 395, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_GenExpr_spec, __pyx_ptype_9pyscipopt_4scip_GenExpr) < 0) __PYX_ERR(1, 395, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_GenExpr = &__pyx_type_9pyscipopt_4scip_GenExpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_GenExpr) < 0) __PYX_ERR(1, 395, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_GenExpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_GenExpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_GenExpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_GenExpr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + #if CYTHON_UPDATE_DESCRIPTOR_DOC + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(1, 395, __pyx_L1_error) + if (__Pyx_IS_TYPE(wrapper, &PyWrapperDescr_Type)) { + __pyx_wrapperbase_9pyscipopt_4scip_7GenExpr___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_9pyscipopt_4scip_7GenExpr___init__.doc = __pyx_doc_9pyscipopt_4scip_7GenExpr___init__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pyscipopt_4scip_7GenExpr___init__; + } + } + #endif + #if CYTHON_UPDATE_DESCRIPTOR_DOC + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr, "__rtruediv__"); if (unlikely(!wrapper)) __PYX_ERR(1, 395, __pyx_L1_error) + if (__Pyx_IS_TYPE(wrapper, &PyWrapperDescr_Type)) { + __pyx_wrapperbase_9pyscipopt_4scip_7GenExpr_12__rtruediv__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_9pyscipopt_4scip_7GenExpr_12__rtruediv__.doc = __pyx_doc_9pyscipopt_4scip_7GenExpr_12__rtruediv__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pyscipopt_4scip_7GenExpr_12__rtruediv__; + } + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_GenExpr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_GenExpr) < 0) __PYX_ERR(1, 395, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_GenExpr) < 0) __PYX_ERR(1, 395, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 562, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_9pyscipopt_4scip_SumExpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_SumExpr_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_9pyscipopt_4scip_SumExpr)) __PYX_ERR(1, 562, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_SumExpr_spec, __pyx_ptype_9pyscipopt_4scip_SumExpr) < 0) __PYX_ERR(1, 562, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_SumExpr = &__pyx_type_9pyscipopt_4scip_SumExpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_9pyscipopt_4scip_SumExpr->tp_base = __pyx_ptype_9pyscipopt_4scip_GenExpr; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_SumExpr) < 0) __PYX_ERR(1, 562, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_SumExpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_SumExpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_SumExpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_SumExpr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SumExpr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_SumExpr) < 0) __PYX_ERR(1, 562, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_SumExpr) < 0) __PYX_ERR(1, 562, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 576, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_9pyscipopt_4scip_ProdExpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_ProdExpr_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_9pyscipopt_4scip_ProdExpr)) __PYX_ERR(1, 576, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_ProdExpr_spec, __pyx_ptype_9pyscipopt_4scip_ProdExpr) < 0) __PYX_ERR(1, 576, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_ProdExpr = &__pyx_type_9pyscipopt_4scip_ProdExpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_9pyscipopt_4scip_ProdExpr->tp_base = __pyx_ptype_9pyscipopt_4scip_GenExpr; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_ProdExpr) < 0) __PYX_ERR(1, 576, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_ProdExpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_ProdExpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_ProdExpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_ProdExpr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ProdExpr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_ProdExpr) < 0) __PYX_ERR(1, 576, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_ProdExpr) < 0) __PYX_ERR(1, 576, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 586, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_9pyscipopt_4scip_VarExpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_VarExpr_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_9pyscipopt_4scip_VarExpr)) __PYX_ERR(1, 586, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_VarExpr_spec, __pyx_ptype_9pyscipopt_4scip_VarExpr) < 0) __PYX_ERR(1, 586, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_VarExpr = &__pyx_type_9pyscipopt_4scip_VarExpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_9pyscipopt_4scip_VarExpr->tp_base = __pyx_ptype_9pyscipopt_4scip_GenExpr; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_VarExpr) < 0) __PYX_ERR(1, 586, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_VarExpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_VarExpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_VarExpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_VarExpr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_VarExpr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_VarExpr) < 0) __PYX_ERR(1, 586, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_VarExpr) < 0) __PYX_ERR(1, 586, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_9pyscipopt_4scip_PowExpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PowExpr_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PowExpr)) __PYX_ERR(1, 595, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PowExpr_spec, __pyx_ptype_9pyscipopt_4scip_PowExpr) < 0) __PYX_ERR(1, 595, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PowExpr = &__pyx_type_9pyscipopt_4scip_PowExpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_9pyscipopt_4scip_PowExpr->tp_base = __pyx_ptype_9pyscipopt_4scip_GenExpr; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PowExpr) < 0) __PYX_ERR(1, 595, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PowExpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PowExpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PowExpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PowExpr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PowExpr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PowExpr) < 0) __PYX_ERR(1, 595, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PowExpr) < 0) __PYX_ERR(1, 595, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_9pyscipopt_4scip_UnaryExpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_UnaryExpr_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_9pyscipopt_4scip_UnaryExpr)) __PYX_ERR(1, 605, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_UnaryExpr_spec, __pyx_ptype_9pyscipopt_4scip_UnaryExpr) < 0) __PYX_ERR(1, 605, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_UnaryExpr = &__pyx_type_9pyscipopt_4scip_UnaryExpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_9pyscipopt_4scip_UnaryExpr->tp_base = __pyx_ptype_9pyscipopt_4scip_GenExpr; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_UnaryExpr) < 0) __PYX_ERR(1, 605, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_UnaryExpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_UnaryExpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_UnaryExpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_UnaryExpr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_UnaryExpr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_UnaryExpr) < 0) __PYX_ERR(1, 605, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_UnaryExpr) < 0) __PYX_ERR(1, 605, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_9pyscipopt_4scip_Constant = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Constant_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Constant)) __PYX_ERR(1, 614, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Constant_spec, __pyx_ptype_9pyscipopt_4scip_Constant) < 0) __PYX_ERR(1, 614, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Constant = &__pyx_type_9pyscipopt_4scip_Constant; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_ptype_9pyscipopt_4scip_Constant->tp_base = __pyx_ptype_9pyscipopt_4scip_GenExpr; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Constant) < 0) __PYX_ERR(1, 614, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Constant->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Constant->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Constant->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Constant->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Constant, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Constant) < 0) __PYX_ERR(1, 614, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Constant) < 0) __PYX_ERR(1, 614, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_LP = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_LP_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_LP)) __PYX_ERR(2, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_LP_spec, __pyx_ptype_9pyscipopt_4scip_LP) < 0) __PYX_ERR(2, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_LP = &__pyx_type_9pyscipopt_4scip_LP; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_LP) < 0) __PYX_ERR(2, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_LP->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_LP->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_LP->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_LP->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + #if CYTHON_UPDATE_DESCRIPTOR_DOC + { + PyObject *wrapper = PyObject_GetAttrString((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(2, 3, __pyx_L1_error) + if (__Pyx_IS_TYPE(wrapper, &PyWrapperDescr_Type)) { + __pyx_wrapperbase_9pyscipopt_4scip_2LP___init__ = *((PyWrapperDescrObject *)wrapper)->d_base; + __pyx_wrapperbase_9pyscipopt_4scip_2LP___init__.doc = __pyx_doc_9pyscipopt_4scip_2LP___init__; + ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_9pyscipopt_4scip_2LP___init__; + } + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_LP, (PyObject *) __pyx_ptype_9pyscipopt_4scip_LP) < 0) __PYX_ERR(2, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_LP) < 0) __PYX_ERR(2, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Benders = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Benders_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Benders)) __PYX_ERR(3, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Benders_spec, __pyx_ptype_9pyscipopt_4scip_Benders) < 0) __PYX_ERR(3, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Benders = &__pyx_type_9pyscipopt_4scip_Benders; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Benders) < 0) __PYX_ERR(3, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Benders->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Benders->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Benders->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Benders->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Benders, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Benders) < 0) __PYX_ERR(3, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Benders) < 0) __PYX_ERR(3, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Benderscut = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Benderscut_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Benderscut)) __PYX_ERR(7, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Benderscut_spec, __pyx_ptype_9pyscipopt_4scip_Benderscut) < 0) __PYX_ERR(7, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Benderscut = &__pyx_type_9pyscipopt_4scip_Benderscut; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Benderscut) < 0) __PYX_ERR(7, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Benderscut->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Benderscut->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Benderscut->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Benderscut->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Benderscut, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Benderscut) < 0) __PYX_ERR(7, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Benderscut) < 0) __PYX_ERR(7, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Branchrule = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Branchrule_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Branchrule)) __PYX_ERR(8, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Branchrule_spec, __pyx_ptype_9pyscipopt_4scip_Branchrule) < 0) __PYX_ERR(8, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Branchrule = &__pyx_type_9pyscipopt_4scip_Branchrule; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Branchrule) < 0) __PYX_ERR(8, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Branchrule->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Branchrule->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Branchrule->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Branchrule->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Branchrule, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Branchrule) < 0) __PYX_ERR(8, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Branchrule) < 0) __PYX_ERR(8, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Conshdlr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Conshdlr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Conshdlr)) __PYX_ERR(9, 4, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Conshdlr_spec, __pyx_ptype_9pyscipopt_4scip_Conshdlr) < 0) __PYX_ERR(9, 4, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Conshdlr = &__pyx_type_9pyscipopt_4scip_Conshdlr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Conshdlr) < 0) __PYX_ERR(9, 4, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Conshdlr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Conshdlr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Conshdlr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Conshdlr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Conshdlr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Conshdlr) < 0) __PYX_ERR(9, 4, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Conshdlr) < 0) __PYX_ERR(9, 4, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Cutsel = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Cutsel_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Cutsel)) __PYX_ERR(10, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Cutsel_spec, __pyx_ptype_9pyscipopt_4scip_Cutsel) < 0) __PYX_ERR(10, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Cutsel = &__pyx_type_9pyscipopt_4scip_Cutsel; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Cutsel) < 0) __PYX_ERR(10, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Cutsel->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Cutsel->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Cutsel->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Cutsel->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Cutsel, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Cutsel) < 0) __PYX_ERR(10, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Cutsel) < 0) __PYX_ERR(10, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Eventhdlr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Eventhdlr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Eventhdlr)) __PYX_ERR(11, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Eventhdlr_spec, __pyx_ptype_9pyscipopt_4scip_Eventhdlr) < 0) __PYX_ERR(11, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Eventhdlr = &__pyx_type_9pyscipopt_4scip_Eventhdlr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Eventhdlr) < 0) __PYX_ERR(11, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Eventhdlr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Eventhdlr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Eventhdlr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Eventhdlr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Eventhdlr, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Eventhdlr) < 0) __PYX_ERR(11, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Eventhdlr) < 0) __PYX_ERR(11, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Heur = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Heur_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Heur)) __PYX_ERR(12, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Heur_spec, __pyx_ptype_9pyscipopt_4scip_Heur) < 0) __PYX_ERR(12, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Heur = &__pyx_type_9pyscipopt_4scip_Heur; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Heur) < 0) __PYX_ERR(12, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Heur->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Heur->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Heur->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Heur->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Heur, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Heur) < 0) __PYX_ERR(12, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Heur) < 0) __PYX_ERR(12, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Presol = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Presol_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Presol)) __PYX_ERR(13, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Presol_spec, __pyx_ptype_9pyscipopt_4scip_Presol) < 0) __PYX_ERR(13, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Presol = &__pyx_type_9pyscipopt_4scip_Presol; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Presol) < 0) __PYX_ERR(13, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Presol->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Presol->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Presol->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Presol->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Presol, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Presol) < 0) __PYX_ERR(13, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Presol) < 0) __PYX_ERR(13, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Pricer = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Pricer_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Pricer)) __PYX_ERR(14, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Pricer_spec, __pyx_ptype_9pyscipopt_4scip_Pricer) < 0) __PYX_ERR(14, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Pricer = &__pyx_type_9pyscipopt_4scip_Pricer; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Pricer) < 0) __PYX_ERR(14, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Pricer->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Pricer->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Pricer->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Pricer->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Pricer, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Pricer) < 0) __PYX_ERR(14, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Pricer) < 0) __PYX_ERR(14, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Prop = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Prop_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Prop)) __PYX_ERR(15, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Prop_spec, __pyx_ptype_9pyscipopt_4scip_Prop) < 0) __PYX_ERR(15, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Prop = &__pyx_type_9pyscipopt_4scip_Prop; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Prop) < 0) __PYX_ERR(15, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Prop->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Prop->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Prop->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Prop->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Prop, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Prop) < 0) __PYX_ERR(15, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Prop) < 0) __PYX_ERR(15, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Sepa = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Sepa_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Sepa)) __PYX_ERR(16, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Sepa_spec, __pyx_ptype_9pyscipopt_4scip_Sepa) < 0) __PYX_ERR(16, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Sepa = &__pyx_type_9pyscipopt_4scip_Sepa; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Sepa) < 0) __PYX_ERR(16, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Sepa->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Sepa->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Sepa->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Sepa->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Sepa, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Sepa) < 0) __PYX_ERR(16, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Sepa) < 0) __PYX_ERR(16, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Reader = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Reader_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Reader)) __PYX_ERR(17, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Reader_spec, __pyx_ptype_9pyscipopt_4scip_Reader) < 0) __PYX_ERR(17, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Reader = &__pyx_type_9pyscipopt_4scip_Reader; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Reader) < 0) __PYX_ERR(17, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Reader->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Reader->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Reader->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Reader->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Reader, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Reader) < 0) __PYX_ERR(17, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Reader) < 0) __PYX_ERR(17, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Relax = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Relax_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Relax)) __PYX_ERR(18, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Relax_spec, __pyx_ptype_9pyscipopt_4scip_Relax) < 0) __PYX_ERR(18, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Relax = &__pyx_type_9pyscipopt_4scip_Relax; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Relax) < 0) __PYX_ERR(18, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Relax->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Relax->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Relax->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Relax->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Relax, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Relax) < 0) __PYX_ERR(18, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Relax) < 0) __PYX_ERR(18, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_Nodesel = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_Nodesel_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_Nodesel)) __PYX_ERR(19, 3, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_Nodesel_spec, __pyx_ptype_9pyscipopt_4scip_Nodesel) < 0) __PYX_ERR(19, 3, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_Nodesel = &__pyx_type_9pyscipopt_4scip_Nodesel; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_Nodesel) < 0) __PYX_ERR(19, 3, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_Nodesel->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_Nodesel->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_Nodesel->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_Nodesel->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Nodesel, (PyObject *) __pyx_ptype_9pyscipopt_4scip_Nodesel) < 0) __PYX_ERR(19, 3, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_Nodesel) < 0) __PYX_ERR(19, 3, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT)) __PYX_ERR(0, 58, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT = &__pyx_type_9pyscipopt_4scip_PY_SCIP_RESULT; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_RESULT, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT) < 0) __PYX_ERR(0, 58, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING)) __PYX_ERR(0, 77, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING = &__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMSETTING; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_PARAMSETTING, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS)) __PYX_ERR(0, 83, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS) < 0) __PYX_ERR(0, 83, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS = &__pyx_type_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS) < 0) __PYX_ERR(0, 83, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_PARAMEMPHASIS, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS) < 0) __PYX_ERR(0, 83, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS) < 0) __PYX_ERR(0, 83, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS)) __PYX_ERR(0, 97, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS) < 0) __PYX_ERR(0, 97, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS = &__pyx_type_9pyscipopt_4scip_PY_SCIP_STATUS; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS) < 0) __PYX_ERR(0, 97, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_STATUS, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS) < 0) __PYX_ERR(0, 97, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS) < 0) __PYX_ERR(0, 97, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE)) __PYX_ERR(0, 118, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE) < 0) __PYX_ERR(0, 118, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE = &__pyx_type_9pyscipopt_4scip_PY_SCIP_STAGE; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE) < 0) __PYX_ERR(0, 118, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_STAGE, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE) < 0) __PYX_ERR(0, 118, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE) < 0) __PYX_ERR(0, 118, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE)) __PYX_ERR(0, 134, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE) < 0) __PYX_ERR(0, 134, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE = &__pyx_type_9pyscipopt_4scip_PY_SCIP_NODETYPE; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE) < 0) __PYX_ERR(0, 134, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_NODETYPE, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE) < 0) __PYX_ERR(0, 134, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE) < 0) __PYX_ERR(0, 134, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING)) __PYX_ERR(0, 148, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING) < 0) __PYX_ERR(0, 148, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING = &__pyx_type_9pyscipopt_4scip_PY_SCIP_PROPTIMING; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING) < 0) __PYX_ERR(0, 148, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_PROPTIMING, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING) < 0) __PYX_ERR(0, 148, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING) < 0) __PYX_ERR(0, 148, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING)) __PYX_ERR(0, 154, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING = &__pyx_type_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_PRESOLTIMING, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING) < 0) __PYX_ERR(0, 154, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING)) __PYX_ERR(0, 160, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING) < 0) __PYX_ERR(0, 160, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING = &__pyx_type_9pyscipopt_4scip_PY_SCIP_HEURTIMING; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING) < 0) __PYX_ERR(0, 160, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_HEURTIMING, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING) < 0) __PYX_ERR(0, 160, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING) < 0) __PYX_ERR(0, 160, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE)) __PYX_ERR(0, 175, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE) < 0) __PYX_ERR(0, 175, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE = &__pyx_type_9pyscipopt_4scip_PY_SCIP_EVENTTYPE; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE) < 0) __PYX_ERR(0, 175, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_EVENTTYPE, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE) < 0) __PYX_ERR(0, 175, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE) < 0) __PYX_ERR(0, 175, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT)) __PYX_ERR(0, 232, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT = &__pyx_type_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_LPSOLSTAT, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR)) __PYX_ERR(0, 242, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR = &__pyx_type_9pyscipopt_4scip_PY_SCIP_BRANCHDIR; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_BRANCHDIR, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE)) __PYX_ERR(0, 248, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE) < 0) __PYX_ERR(0, 248, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE = &__pyx_type_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE) < 0) __PYX_ERR(0, 248, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_BENDERSENFOTYPE, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE) < 0) __PYX_ERR(0, 248, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE) < 0) __PYX_ERR(0, 248, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE)) __PYX_ERR(0, 254, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE_spec, __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE) < 0) __PYX_ERR(0, 254, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE = &__pyx_type_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE) < 0) __PYX_ERR(0, 254, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_PY_SCIP_ROWORIGINTYPE, (PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE) < 0) __PYX_ERR(0, 254, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE) < 0) __PYX_ERR(0, 254, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr)) __PYX_ERR(1, 90, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr_spec, __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr) < 0) __PYX_ERR(1, 90, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr = &__pyx_type_9pyscipopt_4scip___pyx_scope_struct__genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr) < 0) __PYX_ERR(1, 90, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct__genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr)) __PYX_ERR(1, 284, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr_spec, __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(1, 284, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr = &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_1_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr) < 0) __PYX_ERR(1, 284, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_1_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr)) __PYX_ERR(2, 100, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr_spec, __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr) < 0) __PYX_ERR(2, 100, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr = &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_2_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr) < 0) __PYX_ERR(2, 100, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_2_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr)) __PYX_ERR(2, 192, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr_spec, __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(2, 192, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr = &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_3_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr) < 0) __PYX_ERR(2, 192, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_3_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem___spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__)) __PYX_ERR(0, 594, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem___spec, __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__) < 0) __PYX_ERR(0, 594, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__ = &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_4___getitem__; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__) < 0) __PYX_ERR(0, 594, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_4___getitem__->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr_spec, NULL); if (unlikely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr)) __PYX_ERR(0, 600, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr_spec, __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr) < 0) __PYX_ERR(0, 600, __pyx_L1_error) + #else + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr = &__pyx_type_9pyscipopt_4scip___pyx_scope_struct_5_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr) < 0) __PYX_ERR(0, 600, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr->tp_dictoffset && __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_9pyscipopt_4scip___pyx_scope_struct_5_genexpr->tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyTypeObject), + #else + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(20, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(21, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyBoolObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_4bool_bool) __PYX_ERR(21, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType_3_0_10(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), __PYX_GET_STRUCT_ALIGNMENT_3_0_10(PyComplexObject),__Pyx_ImportType_CheckSize_Warn_3_0_10); if (!__pyx_ptype_7cpython_7complex_complex) __PYX_ERR(22, 15, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_scip(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_scip}, + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "scip", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initscip(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initscip(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_scip(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_scip(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +#endif +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else + result = PyDict_SetItemString(moddict, to_name, value); +#endif + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; +#endif + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_scip(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'scip' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("scip", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(5, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "scip" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(5, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(5, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(5, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_scip(void)", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(5, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(5, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(5, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_pyscipopt__scip) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(5, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(5, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "pyscipopt.scip")) { + if (unlikely((PyDict_SetItemString(modules, "pyscipopt.scip", __pyx_m) < 0))) __PYX_ERR(5, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(5, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(5, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(5, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code() < 0))) __PYX_ERR(5, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(5, 1, __pyx_L1_error) + #endif + + /* "src/pyscipopt/scip.pxi":3 + * ##@file scip.pxi + * #@brief holding functions in python that reference the SCIP public functions included in scip.pxd + * import weakref # <<<<<<<<<<<<<< + * from os.path import abspath + * from os.path import splitext + */ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_weakref, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_weakref, __pyx_t_2) < 0) __PYX_ERR(0, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":4 + * #@brief holding functions in python that reference the SCIP public functions included in scip.pxd + * import weakref + * from os.path import abspath # <<<<<<<<<<<<<< + * from os.path import splitext + * import os + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_abspath); + __Pyx_GIVEREF(__pyx_n_s_abspath); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_abspath)) __PYX_ERR(0, 4, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_os_path, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_abspath); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_abspath, __pyx_t_2) < 0) __PYX_ERR(0, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":5 + * import weakref + * from os.path import abspath + * from os.path import splitext # <<<<<<<<<<<<<< + * import os + * import sys + */ + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_splitext); + __Pyx_GIVEREF(__pyx_n_s_splitext); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_splitext)) __PYX_ERR(0, 5, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_os_path, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_splitext); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_splitext, __pyx_t_3) < 0) __PYX_ERR(0, 5, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":6 + * from os.path import abspath + * from os.path import splitext + * import os # <<<<<<<<<<<<<< + * import sys + * import warnings + */ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_os, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":7 + * from os.path import splitext + * import os + * import sys # <<<<<<<<<<<<<< + * import warnings + * import locale + */ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_sys, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) __PYX_ERR(0, 7, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":8 + * import os + * import sys + * import warnings # <<<<<<<<<<<<<< + * import locale + * + */ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_warnings, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_warnings, __pyx_t_2) < 0) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":9 + * import sys + * import warnings + * import locale # <<<<<<<<<<<<<< + * + * cimport cython + */ + __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_locale, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_locale, __pyx_t_2) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/scip.pxi":18 + * from posix.stdio cimport fileno + * + * from collections.abc import Iterable # <<<<<<<<<<<<<< + * from itertools import repeat + * + */ + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_Iterable); + __Pyx_GIVEREF(__pyx_n_s_Iterable); + if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Iterable)) __PYX_ERR(0, 18, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_collections_abc, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_Iterable); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Iterable, __pyx_t_2) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/scip.pxi":19 + * + * from collections.abc import Iterable + * from itertools import repeat # <<<<<<<<<<<<<< + * + * include "expr.pxi" + */ + __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_n_s_repeat); + __Pyx_GIVEREF(__pyx_n_s_repeat); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_repeat)) __PYX_ERR(0, 19, __pyx_L1_error); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_itertools, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_repeat); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_repeat, __pyx_t_3) < 0) __PYX_ERR(0, 19, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":47 + * + * + * def _is_number(e): # <<<<<<<<<<<<<< + * try: + * f = float(e) + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_1_is_number, 0, __pyx_n_s_is_number, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__128)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_number, __pyx_t_2) < 0) __PYX_ERR(1, 47, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":57 + * + * + * def _expr_richcmp(self, other, op): # <<<<<<<<<<<<<< + * if op == 1: # <= + * if isinstance(other, Expr) or isinstance(other, GenExpr): + */ + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3_expr_richcmp, 0, __pyx_n_s_expr_richcmp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__130)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 57, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_expr_richcmp, __pyx_t_2) < 0) __PYX_ERR(1, 57, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":83 + * + * + * class Term: # <<<<<<<<<<<<<< + * '''This is a monomial term''' + * + */ + __pyx_t_2 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_Term, __pyx_n_s_Term, (PyObject *) NULL, __pyx_n_s_pyscipopt_scip, __pyx_kp_s_This_is_a_monomial_term); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "src/pyscipopt/expr.pxi":86 + * '''This is a monomial term''' + * + * __slots__ = ('vartuple', 'ptrtuple', 'hashval') # <<<<<<<<<<<<<< + * + * def __init__(self, *vartuple): + */ + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_slots, __pyx_tuple__131) < 0) __PYX_ERR(1, 86, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":88 + * __slots__ = ('vartuple', 'ptrtuple', 'hashval') + * + * def __init__(self, *vartuple): # <<<<<<<<<<<<<< + * self.vartuple = tuple(sorted(vartuple, key=lambda v: v.ptr())) + * self.ptrtuple = tuple(v.ptr() for v in self.vartuple) + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Term_1__init__, 0, __pyx_n_s_Term___init, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__133)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_init, __pyx_t_3) < 0) __PYX_ERR(1, 88, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":93 + * self.hashval = sum(self.ptrtuple) + * + * def __getitem__(self, idx): # <<<<<<<<<<<<<< + * return self.vartuple[idx] + * + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Term_3__getitem__, 0, __pyx_n_s_Term___getitem, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__135)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 93, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_getitem, __pyx_t_3) < 0) __PYX_ERR(1, 93, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":96 + * return self.vartuple[idx] + * + * def __hash__(self): # <<<<<<<<<<<<<< + * return self.hashval + * + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Term_5__hash__, 0, __pyx_n_s_Term___hash, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__137)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 96, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_hash, __pyx_t_3) < 0) __PYX_ERR(1, 96, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":99 + * return self.hashval + * + * def __eq__(self, other): # <<<<<<<<<<<<<< + * return self.ptrtuple == other.ptrtuple + * + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Term_7__eq__, 0, __pyx_n_s_Term___eq, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__139)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 99, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_eq, __pyx_t_3) < 0) __PYX_ERR(1, 99, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":102 + * return self.ptrtuple == other.ptrtuple + * + * def __len__(self): # <<<<<<<<<<<<<< + * return len(self.vartuple) + * + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Term_9__len__, 0, __pyx_n_s_Term___len, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__140)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_len, __pyx_t_3) < 0) __PYX_ERR(1, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":105 + * return len(self.vartuple) + * + * def __add__(self, other): # <<<<<<<<<<<<<< + * both = self.vartuple + other.vartuple + * return Term(*both) + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Term_11__add__, 0, __pyx_n_s_Term___add, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__142)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_add, __pyx_t_3) < 0) __PYX_ERR(1, 105, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":109 + * return Term(*both) + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return 'Term(%s)' % ', '.join([str(v) for v in self.vartuple]) + * + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Term_13__repr__, 0, __pyx_n_s_Term___repr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__144)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetNameInClass(__pyx_t_2, __pyx_n_s_repr, __pyx_t_3) < 0) __PYX_ERR(1, 109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":83 + * + * + * class Term: # <<<<<<<<<<<<<< + * '''This is a monomial term''' + * + */ + __pyx_t_3 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_n_s_Term, __pyx_empty_tuple, __pyx_t_2, NULL, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 83, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Term, __pyx_t_3) < 0) __PYX_ERR(1, 83, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":113 + * + * + * CONST = Term() # <<<<<<<<<<<<<< + * + * # helper function + */ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_Term); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_CONST, __pyx_t_3) < 0) __PYX_ERR(1, 113, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":116 + * + * # helper function + * def buildGenExprObj(expr): # <<<<<<<<<<<<<< + * """helper function to generate an object of type GenExpr""" + * if _is_number(expr): + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5buildGenExprObj, 0, __pyx_n_s_buildGenExprObj, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__146)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_buildGenExprObj, __pyx_t_3) < 0) __PYX_ERR(1, 116, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":272 + * return _expr_richcmp(self, other, op) + * + * def normalize(self): # <<<<<<<<<<<<<< + * '''remove terms with coefficient of 0''' + * self.terms = {t:c for (t,c) in self.terms.items() if c != 0.0} + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Expr_35normalize, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Expr_normalize, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__148)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr, __pyx_n_s_normalize, __pyx_t_3) < 0) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Expr); + + /* "src/pyscipopt/expr.pxi":279 + * return 'Expr(%s)' % repr(self.terms) + * + * def degree(self): # <<<<<<<<<<<<<< + * '''computes highest degree of terms''' + * if len(self.terms) == 0: + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Expr_39degree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Expr_degree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__150)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr, __pyx_n_s_degree, __pyx_t_3) < 0) __PYX_ERR(1, 279, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Expr); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Expr_41__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Expr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__152)); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(6, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Expr); + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Expr, (type(self), 0x51d2361, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Expr__set_state(self, __pyx_state) + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Expr_43__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Expr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__154)); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Expr, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(6, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Expr); + + /* "src/pyscipopt/expr.pxi":300 + * self.normalize() + * + * def normalize(self): # <<<<<<<<<<<<<< + * '''move constant terms in expression to bounds''' + * if isinstance(self.expr, Expr): + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8ExprCons_3normalize, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ExprCons_normalize, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__156)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 300, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons, __pyx_n_s_normalize, __pyx_t_3) < 0) __PYX_ERR(1, 300, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_9pyscipopt_4scip_ExprCons); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8ExprCons_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ExprCons___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__157)); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(6, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_9pyscipopt_4scip_ExprCons); + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_ExprCons, (type(self), 0x8863d2c, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_ExprCons__set_state(self, __pyx_state) + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8ExprCons_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ExprCons___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__158)); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_ExprCons, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(6, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + PyType_Modified(__pyx_ptype_9pyscipopt_4scip_ExprCons); + + /* "src/pyscipopt/expr.pxi":357 + * raise TypeError(msg) + * + * def quicksum(termlist): # <<<<<<<<<<<<<< + * '''add linear expressions and constants much faster than Python's sum + * by avoiding intermediate data structures and adding terms inplace + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7quicksum, 0, __pyx_n_s_quicksum, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__160)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_quicksum, __pyx_t_3) < 0) __PYX_ERR(1, 357, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":366 + * return result + * + * def quickprod(termlist): # <<<<<<<<<<<<<< + * '''multiply linear expressions and constants by avoiding intermediate + * data structures and multiplying terms inplace + */ + __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9quickprod, 0, __pyx_n_s_quickprod, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__161)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_quickprod, __pyx_t_3) < 0) __PYX_ERR(1, 366, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":376 + * + * + * class Op: # <<<<<<<<<<<<<< + * const = 'const' + * varidx = 'var' + */ + __pyx_t_3 = __Pyx_Py3MetaclassPrepare((PyObject *) NULL, __pyx_empty_tuple, __pyx_n_s_Op, __pyx_n_s_Op, (PyObject *) NULL, __pyx_n_s_pyscipopt_scip, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "src/pyscipopt/expr.pxi":377 + * + * class Op: + * const = 'const' # <<<<<<<<<<<<<< + * varidx = 'var' + * exp, log, sqrt, sin, cos = 'exp', 'log', 'sqrt', 'sin', 'cos' + */ + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_const, __pyx_n_u_const) < 0) __PYX_ERR(1, 377, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":378 + * class Op: + * const = 'const' + * varidx = 'var' # <<<<<<<<<<<<<< + * exp, log, sqrt, sin, cos = 'exp', 'log', 'sqrt', 'sin', 'cos' + * plus, minus, mul, div, power = '+', '-', '*', '/', '**' + */ + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_varidx, __pyx_n_u_var) < 0) __PYX_ERR(1, 378, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":379 + * const = 'const' + * varidx = 'var' + * exp, log, sqrt, sin, cos = 'exp', 'log', 'sqrt', 'sin', 'cos' # <<<<<<<<<<<<<< + * plus, minus, mul, div, power = '+', '-', '*', '/', '**' + * add = 'sum' + */ + __pyx_t_2 = __pyx_n_u_exp; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = __pyx_n_u_log; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = __pyx_n_u_sqrt; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = __pyx_n_u_sin; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_7 = __pyx_n_u_cos; + __Pyx_INCREF(__pyx_t_7); + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_exp, __pyx_t_2) < 0) __PYX_ERR(1, 379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_log, __pyx_t_4) < 0) __PYX_ERR(1, 379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_sqrt, __pyx_t_5) < 0) __PYX_ERR(1, 379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_sin, __pyx_t_6) < 0) __PYX_ERR(1, 379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_cos, __pyx_t_7) < 0) __PYX_ERR(1, 379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "src/pyscipopt/expr.pxi":380 + * varidx = 'var' + * exp, log, sqrt, sin, cos = 'exp', 'log', 'sqrt', 'sin', 'cos' + * plus, minus, mul, div, power = '+', '-', '*', '/', '**' # <<<<<<<<<<<<<< + * add = 'sum' + * prod = 'prod' + */ + __pyx_t_7 = __pyx_kp_u__162; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_6 = __pyx_kp_u__163; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_5 = __pyx_kp_u__126; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_4 = __pyx_kp_u__164; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_2 = __pyx_kp_u__165; + __Pyx_INCREF(__pyx_t_2); + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_plus, __pyx_t_7) < 0) __PYX_ERR(1, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_minus, __pyx_t_6) < 0) __PYX_ERR(1, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_mul_2, __pyx_t_5) < 0) __PYX_ERR(1, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_div, __pyx_t_4) < 0) __PYX_ERR(1, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_power, __pyx_t_2) < 0) __PYX_ERR(1, 380, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "src/pyscipopt/expr.pxi":381 + * exp, log, sqrt, sin, cos = 'exp', 'log', 'sqrt', 'sin', 'cos' + * plus, minus, mul, div, power = '+', '-', '*', '/', '**' + * add = 'sum' # <<<<<<<<<<<<<< + * prod = 'prod' + * fabs = 'abs' + */ + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_add_2, __pyx_n_u_sum) < 0) __PYX_ERR(1, 381, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":382 + * plus, minus, mul, div, power = '+', '-', '*', '/', '**' + * add = 'sum' + * prod = 'prod' # <<<<<<<<<<<<<< + * fabs = 'abs' + * + */ + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_prod, __pyx_n_u_prod) < 0) __PYX_ERR(1, 382, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":383 + * add = 'sum' + * prod = 'prod' + * fabs = 'abs' # <<<<<<<<<<<<<< + * + * Operator = Op() + */ + if (__Pyx_SetNameInClass(__pyx_t_3, __pyx_n_s_fabs, __pyx_n_u_abs) < 0) __PYX_ERR(1, 383, __pyx_L1_error) + + /* "src/pyscipopt/expr.pxi":376 + * + * + * class Op: # <<<<<<<<<<<<<< + * const = 'const' + * varidx = 'var' + */ + __pyx_t_2 = __Pyx_Py3ClassCreate(((PyObject*)&PyType_Type), __pyx_n_s_Op, __pyx_empty_tuple, __pyx_t_3, NULL, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_Op, __pyx_t_2) < 0) __PYX_ERR(1, 376, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "src/pyscipopt/expr.pxi":385 + * fabs = 'abs' + * + * Operator = Op() # <<<<<<<<<<<<<< + * + * ##@details 
 General expressions of variables with operator overloading.
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_Op); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 385, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 385, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Operator, __pyx_t_2) < 0) __PYX_ERR(1, 385, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/expr.pxi":552
+ *         return _expr_richcmp(self, other, op)
+ * 
+ *     def degree(self):             # <<<<<<<<<<<<<<
+ *         '''Note: none of these expressions should be polynomial'''
+ *         return float('inf')
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7GenExpr_27degree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_GenExpr_degree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__166)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 552, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr, __pyx_n_s_degree, __pyx_t_2) < 0) __PYX_ERR(1, 552, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_GenExpr);
+
+  /* "src/pyscipopt/expr.pxi":556
+ *         return float('inf')
+ * 
+ *     def getOp(self):             # <<<<<<<<<<<<<<
+ *         '''returns operator of GenExpr'''
+ *         return self._op
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7GenExpr_29getOp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_GenExpr_getOp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__167)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 556, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr, __pyx_n_s_getOp, __pyx_t_2) < 0) __PYX_ERR(1, 556, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_GenExpr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7GenExpr_31__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_GenExpr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__168)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_GenExpr);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_GenExpr, (type(self), 0xccaf182, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_GenExpr__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7GenExpr_33__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_GenExpr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__169)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_GenExpr, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_GenExpr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7SumExpr_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SumExpr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__170)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_SumExpr, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_SumExpr);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_SumExpr, (type(self), 0x3c52fb7, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_SumExpr__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7SumExpr_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_SumExpr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__171)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_SumExpr, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_SumExpr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8ProdExpr_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ProdExpr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__172)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_ProdExpr, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_ProdExpr);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_ProdExpr, (type(self), 0xe54af0a, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_ProdExpr__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8ProdExpr_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ProdExpr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__173)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_ProdExpr, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_ProdExpr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7VarExpr_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_VarExpr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__174)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_VarExpr, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_VarExpr);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_VarExpr, (type(self), 0x496e932, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_VarExpr__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7VarExpr_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_VarExpr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__175)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_VarExpr, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_VarExpr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7PowExpr_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PowExpr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__176)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PowExpr, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PowExpr);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PowExpr, (type(self), 0x4cfb19d, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PowExpr__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7PowExpr_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PowExpr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__177)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PowExpr, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PowExpr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9UnaryExpr_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_UnaryExpr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__178)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_UnaryExpr);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_UnaryExpr, (type(self), 0xccaf182, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_UnaryExpr__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9UnaryExpr_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_UnaryExpr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__179)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_UnaryExpr, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_UnaryExpr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Constant_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constant___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__180)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constant, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constant);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Constant, (type(self), 0x7e75df4, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Constant__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Constant_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constant___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__181)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constant, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constant);
+
+  /* "src/pyscipopt/expr.pxi":623
+ *         return str(self.number)
+ * 
+ * def exp(expr):             # <<<<<<<<<<<<<<
+ *     """returns expression with exp-function"""
+ *     return UnaryExpr(Operator.exp, buildGenExprObj(expr))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_11exp, 0, __pyx_n_s_exp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__183)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 623, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_exp, __pyx_t_2) < 0) __PYX_ERR(1, 623, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/expr.pxi":626
+ *     """returns expression with exp-function"""
+ *     return UnaryExpr(Operator.exp, buildGenExprObj(expr))
+ * def log(expr):             # <<<<<<<<<<<<<<
+ *     """returns expression with log-function"""
+ *     return UnaryExpr(Operator.log, buildGenExprObj(expr))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_13log, 0, __pyx_n_s_log, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__184)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 626, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_log, __pyx_t_2) < 0) __PYX_ERR(1, 626, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/expr.pxi":629
+ *     """returns expression with log-function"""
+ *     return UnaryExpr(Operator.log, buildGenExprObj(expr))
+ * def sqrt(expr):             # <<<<<<<<<<<<<<
+ *     """returns expression with sqrt-function"""
+ *     return UnaryExpr(Operator.sqrt, buildGenExprObj(expr))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_15sqrt, 0, __pyx_n_s_sqrt, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__185)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 629, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sqrt, __pyx_t_2) < 0) __PYX_ERR(1, 629, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/expr.pxi":632
+ *     """returns expression with sqrt-function"""
+ *     return UnaryExpr(Operator.sqrt, buildGenExprObj(expr))
+ * def sin(expr):             # <<<<<<<<<<<<<<
+ *     """returns expression with sin-function"""
+ *     return UnaryExpr(Operator.sin, buildGenExprObj(expr))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_17sin, 0, __pyx_n_s_sin, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__186)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 632, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sin, __pyx_t_2) < 0) __PYX_ERR(1, 632, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/expr.pxi":635
+ *     """returns expression with sin-function"""
+ *     return UnaryExpr(Operator.sin, buildGenExprObj(expr))
+ * def cos(expr):             # <<<<<<<<<<<<<<
+ *     """returns expression with cos-function"""
+ *     return UnaryExpr(Operator.cos, buildGenExprObj(expr))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_19cos, 0, __pyx_n_s_cos, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__187)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 635, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_cos, __pyx_t_2) < 0) __PYX_ERR(1, 635, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/expr.pxi":639
+ *     return UnaryExpr(Operator.cos, buildGenExprObj(expr))
+ * 
+ * def expr_to_nodes(expr):             # <<<<<<<<<<<<<<
+ *     '''transforms tree to an array of nodes. each node is an operator and the position of the
+ *     children of that operator (i.e. the other nodes) in the array'''
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_21expr_to_nodes, 0, __pyx_n_s_expr_to_nodes, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__189)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 639, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_expr_to_nodes, __pyx_t_2) < 0) __PYX_ERR(1, 639, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/expr.pxi":647
+ *     return nodes
+ * 
+ * def value_to_array(val, nodes):             # <<<<<<<<<<<<<<
+ *     """adds a given value to an array"""
+ *     nodes.append(tuple(['const', [val]]))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_23value_to_array, 0, __pyx_n_s_value_to_array, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__191)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 647, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_value_to_array, __pyx_t_2) < 0) __PYX_ERR(1, 647, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/expr.pxi":657
+ * # also, for sums, we are not considering coefficients, because basically all coefficients are 1
+ * # haven't even consider substractions, but I guess we would interpret them as a - b = a + (-1) * b
+ * def expr_to_array(expr, nodes):             # <<<<<<<<<<<<<<
+ *     """adds expression to array"""
+ *     op = expr._op
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_25expr_to_array, 0, __pyx_n_s_expr_to_array, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__193)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 657, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_expr_to_array, __pyx_t_2) < 0) __PYX_ERR(1, 657, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/lp.pxi":28
+ *         return self.name
+ * 
+ *     def writeLP(self, filename):             # <<<<<<<<<<<<<<
+ *         """Writes LP to a file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_7writeLP, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_writeLP, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__195)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_writeLP, __pyx_t_2) < 0) __PYX_ERR(2, 28, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":36
+ *         PY_SCIP_CALL(SCIPlpiWriteLP(self.lpi, filename))
+ * 
+ *     def readLP(self, filename):             # <<<<<<<<<<<<<<
+ *         """Reads LP from a file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_9readLP, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_readLP, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__196)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_readLP, __pyx_t_2) < 0) __PYX_ERR(2, 36, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":44
+ *         PY_SCIP_CALL(SCIPlpiReadLP(self.lpi, filename))
+ * 
+ *     def infinity(self):             # <<<<<<<<<<<<<<
+ *         """Returns infinity value of the LP.
+ *         """
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_11infinity, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_infinity, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__197)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_infinity, __pyx_t_2) < 0) __PYX_ERR(2, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":49
+ *         return SCIPlpiInfinity(self.lpi)
+ * 
+ *     def isInfinity(self, val):             # <<<<<<<<<<<<<<
+ *         """Checks if a given value is equal to the infinity value of the LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_13isInfinity, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_isInfinity, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__199)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_isInfinity, __pyx_t_2) < 0) __PYX_ERR(2, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":57
+ *         return SCIPlpiIsInfinity(self.lpi, val)
+ * 
+ *     def addCol(self, entries, obj = 0.0, lb = 0.0, ub = None):             # <<<<<<<<<<<<<<
+ *         """Adds a single column to the LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_15addCol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_addCol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__201)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__202);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_addCol, __pyx_t_2) < 0) __PYX_ERR(2, 57, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":89
+ *         free(c_inds)
+ * 
+ *     def addCols(self, entrieslist, objs = None, lbs = None, ubs = None):             # <<<<<<<<<<<<<<
+ *         """Adds multiple columns to the LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_17addCols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_addCols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__204)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__107);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_addCols, __pyx_t_2) < 0) __PYX_ERR(2, 89, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":144
+ *         free(c_objs)
+ * 
+ *     def delCols(self, firstcol, lastcol):             # <<<<<<<<<<<<<<
+ *         """Deletes a range of columns from the LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_19delCols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_delCols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__206)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_delCols, __pyx_t_2) < 0) __PYX_ERR(2, 144, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":153
+ *         PY_SCIP_CALL(SCIPlpiDelCols(self.lpi, firstcol, lastcol))
+ * 
+ *     def addRow(self, entries, lhs=0.0, rhs=None):             # <<<<<<<<<<<<<<
+ *         """Adds a single row to the LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_21addRow, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_addRow, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__208)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__209);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_addRow, __pyx_t_2) < 0) __PYX_ERR(2, 153, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":183
+ *         free(c_inds)
+ * 
+ *     def addRows(self, entrieslist, lhss = None, rhss = None):             # <<<<<<<<<<<<<<
+ *         """Adds multiple rows to the LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_23addRows, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_addRows, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__211)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__212);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_addRows, __pyx_t_2) < 0) __PYX_ERR(2, 183, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":219
+ *         free(c_rhss)
+ * 
+ *     def delRows(self, firstrow, lastrow):             # <<<<<<<<<<<<<<
+ *         """Deletes a range of rows from the LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_25delRows, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_delRows, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__214)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_delRows, __pyx_t_2) < 0) __PYX_ERR(2, 219, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":228
+ *         PY_SCIP_CALL(SCIPlpiDelRows(self.lpi, firstrow, lastrow))
+ * 
+ *     def getBounds(self, firstcol = 0, lastcol = None):             # <<<<<<<<<<<<<<
+ *         """Returns all lower and upper bounds for a range of columns.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_27getBounds, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getBounds, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__216)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__217);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getBounds, __pyx_t_2) < 0) __PYX_ERR(2, 228, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":257
+ *         return lbs, ubs
+ * 
+ *     def getSides(self, firstrow = 0, lastrow = None):             # <<<<<<<<<<<<<<
+ *         """Returns all left- and right-hand sides for a range of rows.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_29getSides, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getSides, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__219)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 257, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__217);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getSides, __pyx_t_2) < 0) __PYX_ERR(2, 257, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":286
+ *         return lhss, rhss
+ * 
+ *     def chgObj(self, col, obj):             # <<<<<<<<<<<<<<
+ *         """Changes objective coefficient of a single column.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_31chgObj, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_chgObj, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__221)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 286, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_chgObj, __pyx_t_2) < 0) __PYX_ERR(2, 286, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":297
+ *         PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj))
+ * 
+ *     def chgCoef(self, row, col, newval):             # <<<<<<<<<<<<<<
+ *         """Changes a single coefficient in the LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_33chgCoef, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_chgCoef, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__223)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 297, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_chgCoef, __pyx_t_2) < 0) __PYX_ERR(2, 297, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":307
+ *         PY_SCIP_CALL(SCIPlpiChgCoef(self.lpi, row, col, newval))
+ * 
+ *     def chgBound(self, col, lb, ub):             # <<<<<<<<<<<<<<
+ *         """Changes the lower and upper bound of a single column.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_35chgBound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_chgBound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__225)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 307, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_chgBound, __pyx_t_2) < 0) __PYX_ERR(2, 307, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":320
+ *         PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub))
+ * 
+ *     def chgSide(self, row, lhs, rhs):             # <<<<<<<<<<<<<<
+ *         """Changes the left- and right-hand side of a single row.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_37chgSide, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_chgSide, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__227)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 320, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_chgSide, __pyx_t_2) < 0) __PYX_ERR(2, 320, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":333
+ *         PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs))
+ * 
+ *     def clear(self):             # <<<<<<<<<<<<<<
+ *         """Clears the whole LP."""
+ *         PY_SCIP_CALL(SCIPlpiClear(self.lpi))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_39clear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_clear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__228)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 333, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_clear, __pyx_t_2) < 0) __PYX_ERR(2, 333, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":337
+ *         PY_SCIP_CALL(SCIPlpiClear(self.lpi))
+ * 
+ *     def nrows(self):             # <<<<<<<<<<<<<<
+ *         """Returns the number of rows."""
+ *         cdef int nrows
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_41nrows, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_nrows, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__230)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_nrows, __pyx_t_2) < 0) __PYX_ERR(2, 337, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":343
+ *         return nrows
+ * 
+ *     def ncols(self):             # <<<<<<<<<<<<<<
+ *         """Returns the number of columns."""
+ *         cdef int ncols
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_43ncols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_ncols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__232)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 343, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_ncols, __pyx_t_2) < 0) __PYX_ERR(2, 343, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":349
+ *         return ncols
+ * 
+ *     def solve(self, dual=True):             # <<<<<<<<<<<<<<
+ *         """Solves the current LP.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_45solve, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_solve, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__234)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 349, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_solve, __pyx_t_2) < 0) __PYX_ERR(2, 349, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":364
+ *         return objval
+ * 
+ *     def getPrimal(self):             # <<<<<<<<<<<<<<
+ *         """Returns the primal solution of the last LP solve."""
+ *         ncols = self.ncols()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_47getPrimal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getPrimal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__236)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 364, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getPrimal, __pyx_t_2) < 0) __PYX_ERR(2, 364, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":376
+ *         return primalsol
+ * 
+ *     def isPrimalFeasible(self):             # <<<<<<<<<<<<<<
+ *         """Returns True iff LP is proven to be primal feasible."""
+ *         return SCIPlpiIsPrimalFeasible(self.lpi)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_49isPrimalFeasible, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_isPrimalFeasible, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__237)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 376, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_isPrimalFeasible, __pyx_t_2) < 0) __PYX_ERR(2, 376, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":380
+ *         return SCIPlpiIsPrimalFeasible(self.lpi)
+ * 
+ *     def getDual(self):             # <<<<<<<<<<<<<<
+ *         """Returns the dual solution of the last LP solve."""
+ *         nrows = self.nrows()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_51getDual, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getDual, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__239)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 380, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getDual, __pyx_t_2) < 0) __PYX_ERR(2, 380, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":392
+ *         return dualsol
+ * 
+ *     def isDualFeasible(self):             # <<<<<<<<<<<<<<
+ *         """Returns True iff LP is proven to be dual feasible."""
+ *         return SCIPlpiIsDualFeasible(self.lpi)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_53isDualFeasible, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_isDualFeasible, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__240)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 392, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_isDualFeasible, __pyx_t_2) < 0) __PYX_ERR(2, 392, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":396
+ *         return SCIPlpiIsDualFeasible(self.lpi)
+ * 
+ *     def getPrimalRay(self):             # <<<<<<<<<<<<<<
+ *         """Returns a primal ray if possible, None otherwise."""
+ *         if not SCIPlpiHasPrimalRay(self.lpi):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_55getPrimalRay, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getPrimalRay, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__242)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 396, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getPrimalRay, __pyx_t_2) < 0) __PYX_ERR(2, 396, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":410
+ *         return ray
+ * 
+ *     def getDualRay(self):             # <<<<<<<<<<<<<<
+ *         """Returns a dual ray if possible, None otherwise."""
+ *         if not SCIPlpiHasDualRay(self.lpi):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_57getDualRay, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getDualRay, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__244)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 410, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getDualRay, __pyx_t_2) < 0) __PYX_ERR(2, 410, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":424
+ *         return ray
+ * 
+ *     def getNIterations(self):             # <<<<<<<<<<<<<<
+ *         """Returns the number of LP iterations of the last LP solve."""
+ *         cdef int niters
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_59getNIterations, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getNIterations, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__246)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 424, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getNIterations, __pyx_t_2) < 0) __PYX_ERR(2, 424, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":430
+ *         return niters
+ * 
+ *     def getRedcost(self):             # <<<<<<<<<<<<<<
+ *         """Returns the reduced cost vector of the last LP solve."""
+ *         ncols = self.ncols()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_61getRedcost, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getRedcost, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__248)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 430, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getRedcost, __pyx_t_2) < 0) __PYX_ERR(2, 430, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "src/pyscipopt/lp.pxi":444
+ *         return redcost
+ * 
+ *     def getBasisInds(self):             # <<<<<<<<<<<<<<
+ *         """Returns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1"""
+ *         nrows = self.nrows()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_63getBasisInds, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP_getBasisInds, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__250)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 444, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_LP, __pyx_n_s_getBasisInds, __pyx_t_2) < 0) __PYX_ERR(2, 444, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_LP);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.lpi cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_65__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__251)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.lpi cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.lpi cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_2LP_67__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_LP___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__252)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/benders.pxi":8
+ *     cdef SCIP_BENDERS* _benders
+ * 
+ *     def bendersfree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of Benders decomposition '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_1bendersfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__253)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersfree, __pyx_t_2) < 0) __PYX_ERR(3, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":12
+ *         pass
+ * 
+ *     def bendersinit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes Benders deconposition'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_3bendersinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__254)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersinit, __pyx_t_2) < 0) __PYX_ERR(3, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":16
+ *         pass
+ * 
+ *     def bendersexit(self):             # <<<<<<<<<<<<<<
+ *         '''calls exit method of Benders decomposition'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_5bendersexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__255)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersexit, __pyx_t_2) < 0) __PYX_ERR(3, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":20
+ *         pass
+ * 
+ *     def bendersinitpre(self):             # <<<<<<<<<<<<<<
+ *         '''informs the Benders decomposition that the presolving process is being started '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_7bendersinitpre, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersinitpre, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__256)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersinitpre, __pyx_t_2) < 0) __PYX_ERR(3, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":24
+ *         pass
+ * 
+ *     def bendersexitpre(self):             # <<<<<<<<<<<<<<
+ *         '''informs the Benders decomposition that the presolving process has been completed'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_9bendersexitpre, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersexitpre, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__257)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersexitpre, __pyx_t_2) < 0) __PYX_ERR(3, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":28
+ *         pass
+ * 
+ *     def bendersinitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs Benders decomposition that the branch and bound process is being started '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_11bendersinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__258)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersinitsol, __pyx_t_2) < 0) __PYX_ERR(3, 28, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":32
+ *         pass
+ * 
+ *     def bendersexitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs Benders decomposition that the branch and bound process data is being freed'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_13bendersexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__259)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersexitsol, __pyx_t_2) < 0) __PYX_ERR(3, 32, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":36
+ *         pass
+ * 
+ *     def benderscreatesub(self, probnumber):             # <<<<<<<<<<<<<<
+ *         '''creates the subproblems and registers it with the Benders decomposition struct '''
+ *         print("python error in benderscreatesub: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_15benderscreatesub, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_benderscreatesub, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__261)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_benderscreatesub, __pyx_t_2) < 0) __PYX_ERR(3, 36, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":41
+ *         return {}
+ * 
+ *     def benderspresubsolve(self, solution, enfotype, checkint):             # <<<<<<<<<<<<<<
+ *         '''sets the pre subproblem solve callback of Benders decomposition '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_17benderspresubsolve, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_benderspresubsolve, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__263)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_benderspresubsolve, __pyx_t_2) < 0) __PYX_ERR(3, 41, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":45
+ *         return {}
+ * 
+ *     def benderssolvesubconvex(self, solution, probnumber, onlyconvex):             # <<<<<<<<<<<<<<
+ *         '''sets convex solve callback of Benders decomposition'''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_19benderssolvesubconvex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_benderssolvesubconvex, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__265)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_benderssolvesubconvex, __pyx_t_2) < 0) __PYX_ERR(3, 45, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":49
+ *         return {}
+ * 
+ *     def benderssolvesub(self, solution, probnumber):             # <<<<<<<<<<<<<<
+ *         '''sets solve callback of Benders decomposition '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_21benderssolvesub, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_benderssolvesub, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__267)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_benderssolvesub, __pyx_t_2) < 0) __PYX_ERR(3, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":53
+ *         return {}
+ * 
+ *     def benderspostsolve(self, solution, enfotype, mergecandidates, npriomergecands, checkint, infeasible):             # <<<<<<<<<<<<<<
+ *         '''sets post-solve callback of Benders decomposition '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_23benderspostsolve, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_benderspostsolve, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__269)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_benderspostsolve, __pyx_t_2) < 0) __PYX_ERR(3, 53, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":57
+ *         return {}
+ * 
+ *     def bendersfreesub(self, probnumber):             # <<<<<<<<<<<<<<
+ *         '''frees the subproblems'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_25bendersfreesub, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersfreesub, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__270)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersfreesub, __pyx_t_2) < 0) __PYX_ERR(3, 57, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "src/pyscipopt/benders.pxi":61
+ *         pass
+ * 
+ *     def bendersgetvar(self, variable, probnumber):             # <<<<<<<<<<<<<<
+ *         '''Returns the corresponding master or subproblem variable for the given variable. This provides a call back for the variable mapping between the master and subproblems. '''
+ *         print("python error in bendersgetvar: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_27bendersgetvar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders_bendersgetvar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__272)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benders, __pyx_n_s_bendersgetvar, __pyx_t_2) < 0) __PYX_ERR(3, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benders);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._benders cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_29__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__273)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self._benders cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._benders cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Benders_31__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benders___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__274)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/benderscut.pxi":8
+ *     cdef public str name
+ * 
+ *     def benderscutfree(self):             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Benderscut_1benderscutfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benderscut_benderscutfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__275)); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut, __pyx_n_s_benderscutfree, __pyx_t_2) < 0) __PYX_ERR(7, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benderscut);
+
+  /* "src/pyscipopt/benderscut.pxi":11
+ *         pass
+ * 
+ *     def benderscutinit(self):             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Benderscut_3benderscutinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benderscut_benderscutinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__276)); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut, __pyx_n_s_benderscutinit, __pyx_t_2) < 0) __PYX_ERR(7, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benderscut);
+
+  /* "src/pyscipopt/benderscut.pxi":14
+ *         pass
+ * 
+ *     def benderscutexit(self):             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Benderscut_5benderscutexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benderscut_benderscutexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__277)); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut, __pyx_n_s_benderscutexit, __pyx_t_2) < 0) __PYX_ERR(7, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benderscut);
+
+  /* "src/pyscipopt/benderscut.pxi":17
+ *         pass
+ * 
+ *     def benderscutinitsol(self):             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Benderscut_7benderscutinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benderscut_benderscutinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__278)); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 17, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut, __pyx_n_s_benderscutinitsol, __pyx_t_2) < 0) __PYX_ERR(7, 17, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benderscut);
+
+  /* "src/pyscipopt/benderscut.pxi":20
+ *         pass
+ * 
+ *     def benderscutexitsol(self):             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Benderscut_9benderscutexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benderscut_benderscutexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__279)); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut, __pyx_n_s_benderscutexitsol, __pyx_t_2) < 0) __PYX_ERR(7, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benderscut);
+
+  /* "src/pyscipopt/benderscut.pxi":23
+ *         pass
+ * 
+ *     def benderscutexec(self, solution, probnumber, enfotype):             # <<<<<<<<<<<<<<
+ *         print("python error in benderscutexec: this method needs to be implemented")
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Benderscut_11benderscutexec, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benderscut_benderscutexec, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__281)); if (unlikely(!__pyx_t_2)) __PYX_ERR(7, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut, __pyx_n_s_benderscutexec, __pyx_t_2) < 0) __PYX_ERR(7, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benderscut);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Benderscut_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benderscut___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__282)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benderscut);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Benderscut, (type(self), 0x5af043b, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Benderscut__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Benderscut_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Benderscut___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__283)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Benderscut, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Benderscut);
+
+  /* "src/pyscipopt/branchrule.pxi":6
+ *     cdef public Model model
+ * 
+ *     def branchfree(self):             # <<<<<<<<<<<<<<
+ *         '''frees memory of branching rule'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_1branchfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule_branchfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__284)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_branchfree, __pyx_t_2) < 0) __PYX_ERR(8, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "src/pyscipopt/branchrule.pxi":10
+ *         pass
+ * 
+ *     def branchinit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes branching rule'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_3branchinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule_branchinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__285)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_branchinit, __pyx_t_2) < 0) __PYX_ERR(8, 10, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "src/pyscipopt/branchrule.pxi":14
+ *         pass
+ * 
+ *     def branchexit(self):             # <<<<<<<<<<<<<<
+ *         '''deinitializes branching rule'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_5branchexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule_branchexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__286)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_branchexit, __pyx_t_2) < 0) __PYX_ERR(8, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "src/pyscipopt/branchrule.pxi":18
+ *         pass
+ * 
+ *     def branchinitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs branching rule that the branch and bound process is being started '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_7branchinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule_branchinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__287)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_branchinitsol, __pyx_t_2) < 0) __PYX_ERR(8, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "src/pyscipopt/branchrule.pxi":22
+ *         pass
+ * 
+ *     def branchexitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs branching rule that the branch and bound process data is being freed'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_9branchexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule_branchexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__288)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_branchexitsol, __pyx_t_2) < 0) __PYX_ERR(8, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "src/pyscipopt/branchrule.pxi":26
+ *         pass
+ * 
+ *     def branchexeclp(self, allowaddcons):             # <<<<<<<<<<<<<<
+ *         '''executes branching rule for fractional LP solution'''
+ *         raise NotImplementedError("branchexeclp() is a fundamental callback and should be implemented in the derived "
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_11branchexeclp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule_branchexeclp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__290)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_branchexeclp, __pyx_t_2) < 0) __PYX_ERR(8, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "src/pyscipopt/branchrule.pxi":31
+ *                                   "class")
+ * 
+ *     def branchexecext(self, allowaddcons):             # <<<<<<<<<<<<<<
+ *         '''executes branching rule for external branching candidates '''
+ *         raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_13branchexecext, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule_branchexecext, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__291)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_branchexecext, __pyx_t_2) < 0) __PYX_ERR(8, 31, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "src/pyscipopt/branchrule.pxi":35
+ *         raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class")
+ * 
+ *     def branchexecps(self, allowaddcons):             # <<<<<<<<<<<<<<
+ *         '''executes branching rule for not completely fixed pseudo solution '''
+ *         # this method needs to be implemented by the user
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_15branchexecps, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule_branchexecps, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__292)); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 35, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_branchexecps, __pyx_t_2) < 0) __PYX_ERR(8, 35, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__293)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Branchrule, (type(self), 0x9372c47, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Branchrule__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Branchrule_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Branchrule___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__294)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Branchrule, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Branchrule);
+
+  /* "src/pyscipopt/conshdlr.pxi":8
+ *     cdef public str name
+ * 
+ *     def consfree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_1consfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__295)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 8, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consfree, __pyx_t_2) < 0) __PYX_ERR(9, 8, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":12
+ *         pass
+ * 
+ *     def consinit(self, constraints):             # <<<<<<<<<<<<<<
+ *         '''calls initialization method of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_3consinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__297)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consinit, __pyx_t_2) < 0) __PYX_ERR(9, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":16
+ *         pass
+ * 
+ *     def consexit(self, constraints):             # <<<<<<<<<<<<<<
+ *         '''calls exit method of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_5consexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__298)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consexit, __pyx_t_2) < 0) __PYX_ERR(9, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":20
+ *         pass
+ * 
+ *     def consinitpre(self, constraints):             # <<<<<<<<<<<<<<
+ *         '''informs constraint handler that the presolving process is being started '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_7consinitpre, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consinitpre, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__299)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consinitpre, __pyx_t_2) < 0) __PYX_ERR(9, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":24
+ *         pass
+ * 
+ *     def consexitpre(self, constraints):             # <<<<<<<<<<<<<<
+ *         '''informs constraint handler that the presolving is finished '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_9consexitpre, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consexitpre, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__300)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consexitpre, __pyx_t_2) < 0) __PYX_ERR(9, 24, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":28
+ *         pass
+ * 
+ *     def consinitsol(self, constraints):             # <<<<<<<<<<<<<<
+ *         '''informs constraint handler that the branch and bound process is being started '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_11consinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__301)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consinitsol, __pyx_t_2) < 0) __PYX_ERR(9, 28, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":32
+ *         pass
+ * 
+ *     def consexitsol(self, constraints, restart):             # <<<<<<<<<<<<<<
+ *         '''informs constraint handler that the branch and bound process data is being freed '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_13consexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__303)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consexitsol, __pyx_t_2) < 0) __PYX_ERR(9, 32, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":36
+ *         pass
+ * 
+ *     def consdelete(self, constraint):             # <<<<<<<<<<<<<<
+ *         '''sets method of constraint handler to free specific constraint data '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_15consdelete, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consdelete, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__305)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consdelete, __pyx_t_2) < 0) __PYX_ERR(9, 36, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":40
+ *         pass
+ * 
+ *     def constrans(self, sourceconstraint):             # <<<<<<<<<<<<<<
+ *         '''sets method of constraint handler to transform constraint data into data belonging to the transformed problem '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_17constrans, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_constrans, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__307)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_constrans, __pyx_t_2) < 0) __PYX_ERR(9, 40, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":44
+ *         return {}
+ * 
+ *     def consinitlp(self, constraints):             # <<<<<<<<<<<<<<
+ *         '''calls LP initialization method of constraint handler to separate all initial active constraints '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_19consinitlp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consinitlp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__308)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consinitlp, __pyx_t_2) < 0) __PYX_ERR(9, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":48
+ *         return {}
+ * 
+ *     def conssepalp(self, constraints, nusefulconss):             # <<<<<<<<<<<<<<
+ *         '''calls separator method of constraint handler to separate LP solution '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_21conssepalp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_conssepalp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__310)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_conssepalp, __pyx_t_2) < 0) __PYX_ERR(9, 48, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":52
+ *         return {}
+ * 
+ *     def conssepasol(self, constraints, nusefulconss, solution):             # <<<<<<<<<<<<<<
+ *         '''calls separator method of constraint handler to separate given primal solution '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_23conssepasol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_conssepasol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__312)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_conssepasol, __pyx_t_2) < 0) __PYX_ERR(9, 52, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":56
+ *         return {}
+ * 
+ *     def consenfolp(self, constraints, nusefulconss, solinfeasible):             # <<<<<<<<<<<<<<
+ *         '''calls enforcing method of constraint handler for LP solution for all constraints added'''
+ *         print("python error in consenfolp: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_25consenfolp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consenfolp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__314)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consenfolp, __pyx_t_2) < 0) __PYX_ERR(9, 56, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":61
+ *         return {}
+ * 
+ *     def consenforelax(self, solution, constraints, nusefulconss, solinfeasible):             # <<<<<<<<<<<<<<
+ *         '''calls enforcing method of constraint handler for a relaxation solution for all constraints added'''
+ *         print("python error in consenforelax: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_27consenforelax, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consenforelax, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__316)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consenforelax, __pyx_t_2) < 0) __PYX_ERR(9, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":66
+ *         return {}
+ * 
+ *     def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible):             # <<<<<<<<<<<<<<
+ *         '''calls enforcing method of constraint handler for pseudo solution for all constraints added'''
+ *         print("python error in consenfops: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_29consenfops, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consenfops, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__318)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consenfops, __pyx_t_2) < 0) __PYX_ERR(9, 66, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":71
+ *         return {}
+ * 
+ *     def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely):             # <<<<<<<<<<<<<<
+ *         '''calls feasibility check method of constraint handler '''
+ *         print("python error in conscheck: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_31conscheck, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_conscheck, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__320)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_conscheck, __pyx_t_2) < 0) __PYX_ERR(9, 71, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":76
+ *         return {}
+ * 
+ *     def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming):             # <<<<<<<<<<<<<<
+ *         '''calls propagation method of constraint handler '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_33consprop, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consprop, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__322)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consprop, __pyx_t_2) < 0) __PYX_ERR(9, 76, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":80
+ *         return {}
+ * 
+ *     def conspresol(self, constraints, nrounds, presoltiming,             # <<<<<<<<<<<<<<
+ *                    nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,
+ *                    nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_35conspresol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_conspresol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__324)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_conspresol, __pyx_t_2) < 0) __PYX_ERR(9, 80, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":86
+ *         return result_dict
+ * 
+ *     def consresprop(self):             # <<<<<<<<<<<<<<
+ *         '''sets propagation conflict resolving method of constraint handler '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_37consresprop, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consresprop, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__325)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consresprop, __pyx_t_2) < 0) __PYX_ERR(9, 86, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":90
+ *         return {}
+ * 
+ *     def conslock(self, constraint, locktype, nlockspos, nlocksneg):             # <<<<<<<<<<<<<<
+ *         '''variable rounding lock method of constraint handler'''
+ *         print("python error in conslock: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_39conslock, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_conslock, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__327)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_conslock, __pyx_t_2) < 0) __PYX_ERR(9, 90, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":95
+ *         return {}
+ * 
+ *     def consactive(self, constraint):             # <<<<<<<<<<<<<<
+ *         '''sets activation notification method of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_41consactive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consactive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__328)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consactive, __pyx_t_2) < 0) __PYX_ERR(9, 95, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":99
+ *         pass
+ * 
+ *     def consdeactive(self, constraint):             # <<<<<<<<<<<<<<
+ *         '''sets deactivation notification method of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_43consdeactive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consdeactive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__329)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consdeactive, __pyx_t_2) < 0) __PYX_ERR(9, 99, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":103
+ *         pass
+ * 
+ *     def consenable(self, constraint):             # <<<<<<<<<<<<<<
+ *         '''sets enabling notification method of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_45consenable, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consenable, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__330)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consenable, __pyx_t_2) < 0) __PYX_ERR(9, 103, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":107
+ *         pass
+ * 
+ *     def consdisable(self, constraint):             # <<<<<<<<<<<<<<
+ *         '''sets disabling notification method of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_47consdisable, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consdisable, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__331)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 107, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consdisable, __pyx_t_2) < 0) __PYX_ERR(9, 107, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":111
+ *         pass
+ * 
+ *     def consdelvars(self, constraints):             # <<<<<<<<<<<<<<
+ *         '''calls variable deletion method of constraint handler'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_49consdelvars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consdelvars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__332)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consdelvars, __pyx_t_2) < 0) __PYX_ERR(9, 111, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":115
+ *         pass
+ * 
+ *     def consprint(self, constraint):             # <<<<<<<<<<<<<<
+ *         '''sets constraint display method of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_51consprint, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consprint, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__333)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 115, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consprint, __pyx_t_2) < 0) __PYX_ERR(9, 115, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":119
+ *         pass
+ * 
+ *     def conscopy(self):             # <<<<<<<<<<<<<<
+ *         '''sets copy method of both the constraint handler and each associated constraint'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_53conscopy, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_conscopy, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__334)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_conscopy, __pyx_t_2) < 0) __PYX_ERR(9, 119, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":123
+ *         pass
+ * 
+ *     def consparse(self):             # <<<<<<<<<<<<<<
+ *         '''sets constraint parsing method of constraint handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_55consparse, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consparse, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__335)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consparse, __pyx_t_2) < 0) __PYX_ERR(9, 123, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":127
+ *         pass
+ * 
+ *     def consgetvars(self, constraint):             # <<<<<<<<<<<<<<
+ *         '''sets constraint variable getter method of constraint handler'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_57consgetvars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consgetvars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__336)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consgetvars, __pyx_t_2) < 0) __PYX_ERR(9, 127, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":131
+ *         pass
+ * 
+ *     def consgetnvars(self, constraint):             # <<<<<<<<<<<<<<
+ *         '''sets constraint variable number getter method of constraint handler '''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_59consgetnvars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consgetnvars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__337)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consgetnvars, __pyx_t_2) < 0) __PYX_ERR(9, 131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":135
+ *         return {}
+ * 
+ *     def consgetdivebdchgs(self):             # <<<<<<<<<<<<<<
+ *         '''calls diving solution enforcement callback of constraint handler, if it exists '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_61consgetdivebdchgs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consgetdivebdchgs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__338)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consgetdivebdchgs, __pyx_t_2) < 0) __PYX_ERR(9, 135, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":139
+ *         pass
+ * 
+ *     def consgetpermsymgraph(self):             # <<<<<<<<<<<<<<
+ *         '''permutation symmetry detection graph getter callback, if it exists '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_63consgetpermsymgraph, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consgetpermsymgraph, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__339)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consgetpermsymgraph, __pyx_t_2) < 0) __PYX_ERR(9, 139, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/conshdlr.pxi":143
+ *         pass
+ * 
+ *     def consgetsignedpermsymgraph(self):             # <<<<<<<<<<<<<<
+ *         '''signed permutation symmetry detection graph getter callback, if it exists '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_65consgetsignedpermsymgraph, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr_consgetsignedpermsymgra, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__340)); if (unlikely(!__pyx_t_2)) __PYX_ERR(9, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_consgetsignedpermsymgraph, __pyx_t_2) < 0) __PYX_ERR(9, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_67__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__341)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Conshdlr, (type(self), 0x48f811e, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Conshdlr__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Conshdlr_69__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Conshdlr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__342)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Conshdlr, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Conshdlr);
+
+  /* "src/pyscipopt/cutsel.pxi":6
+ *   cdef public Model model
+ * 
+ *   def cutselfree(self):             # <<<<<<<<<<<<<<
+ *     '''frees memory of cut selector'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Cutsel_1cutselfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Cutsel_cutselfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__343)); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel, __pyx_n_s_cutselfree, __pyx_t_2) < 0) __PYX_ERR(10, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Cutsel);
+
+  /* "src/pyscipopt/cutsel.pxi":10
+ *     pass
+ * 
+ *   def cutselinit(self):             # <<<<<<<<<<<<<<
+ *     ''' executed after the problem is transformed. use this call to initialize cut selector data.'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Cutsel_3cutselinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Cutsel_cutselinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__344)); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel, __pyx_n_s_cutselinit, __pyx_t_2) < 0) __PYX_ERR(10, 10, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Cutsel);
+
+  /* "src/pyscipopt/cutsel.pxi":14
+ *     pass
+ * 
+ *   def cutselexit(self):             # <<<<<<<<<<<<<<
+ *     '''executed before the transformed problem is freed'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Cutsel_5cutselexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Cutsel_cutselexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__345)); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel, __pyx_n_s_cutselexit, __pyx_t_2) < 0) __PYX_ERR(10, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Cutsel);
+
+  /* "src/pyscipopt/cutsel.pxi":18
+ *     pass
+ * 
+ *   def cutselinitsol(self):             # <<<<<<<<<<<<<<
+ *     '''executed when the presolving is finished and the branch-and-bound process is about to begin'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Cutsel_7cutselinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Cutsel_cutselinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__346)); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel, __pyx_n_s_cutselinitsol, __pyx_t_2) < 0) __PYX_ERR(10, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Cutsel);
+
+  /* "src/pyscipopt/cutsel.pxi":22
+ *     pass
+ * 
+ *   def cutselexitsol(self):             # <<<<<<<<<<<<<<
+ *     '''executed before the branch-and-bound process is freed'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Cutsel_9cutselexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Cutsel_cutselexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__347)); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel, __pyx_n_s_cutselexitsol, __pyx_t_2) < 0) __PYX_ERR(10, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Cutsel);
+
+  /* "src/pyscipopt/cutsel.pxi":26
+ *     pass
+ * 
+ *   def cutselselect(self, cuts, forcedcuts, root, maxnselectedcuts):             # <<<<<<<<<<<<<<
+ *     '''first method called in each iteration in the main solving loop. '''
+ *     # this method needs to be implemented by the user
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Cutsel_11cutselselect, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Cutsel_cutselselect, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__349)); if (unlikely(!__pyx_t_2)) __PYX_ERR(10, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel, __pyx_n_s_cutselselect, __pyx_t_2) < 0) __PYX_ERR(10, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Cutsel);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Cutsel_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Cutsel___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__350)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Cutsel);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Cutsel, (type(self), 0x9372c47, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Cutsel__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Cutsel_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Cutsel___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__351)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Cutsel, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Cutsel);
+
+  /* "src/pyscipopt/event.pxi":7
+ *     cdef public str name
+ * 
+ *     def eventcopy(self):             # <<<<<<<<<<<<<<
+ *         '''sets copy callback for all events of this event handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_1eventcopy, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr_eventcopy, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__352)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_eventcopy, __pyx_t_2) < 0) __PYX_ERR(11, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "src/pyscipopt/event.pxi":11
+ *         pass
+ * 
+ *     def eventfree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of event handler '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_3eventfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr_eventfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__353)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_eventfree, __pyx_t_2) < 0) __PYX_ERR(11, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "src/pyscipopt/event.pxi":15
+ *         pass
+ * 
+ *     def eventinit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes event handler'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_5eventinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr_eventinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__354)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_eventinit, __pyx_t_2) < 0) __PYX_ERR(11, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "src/pyscipopt/event.pxi":19
+ *         pass
+ * 
+ *     def eventexit(self):             # <<<<<<<<<<<<<<
+ *         '''calls exit method of event handler'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_7eventexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr_eventexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__355)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_eventexit, __pyx_t_2) < 0) __PYX_ERR(11, 19, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "src/pyscipopt/event.pxi":23
+ *         pass
+ * 
+ *     def eventinitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs event handler that the branch and bound process is being started '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_9eventinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr_eventinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__356)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_eventinitsol, __pyx_t_2) < 0) __PYX_ERR(11, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "src/pyscipopt/event.pxi":27
+ *         pass
+ * 
+ *     def eventexitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs event handler that the branch and bound process data is being freed '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_11eventexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr_eventexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__357)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 27, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_eventexitsol, __pyx_t_2) < 0) __PYX_ERR(11, 27, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "src/pyscipopt/event.pxi":31
+ *         pass
+ * 
+ *     def eventdelete(self):             # <<<<<<<<<<<<<<
+ *         '''sets callback to free specific event data'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_13eventdelete, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr_eventdelete, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__358)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_eventdelete, __pyx_t_2) < 0) __PYX_ERR(11, 31, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "src/pyscipopt/event.pxi":35
+ *         pass
+ * 
+ *     def eventexec(self, event):             # <<<<<<<<<<<<<<
+ *         '''calls execution method of event handler '''
+ *         print("python error in eventexec: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_15eventexec, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr_eventexec, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__360)); if (unlikely(!__pyx_t_2)) __PYX_ERR(11, 35, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_eventexec, __pyx_t_2) < 0) __PYX_ERR(11, 35, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__361)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Eventhdlr, (type(self), 0x48f811e, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Eventhdlr__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_9Eventhdlr_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Eventhdlr___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__362)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Eventhdlr, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Eventhdlr);
+
+  /* "src/pyscipopt/heuristic.pxi":7
+ *     cdef public str name
+ * 
+ *     def heurfree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of primal heuristic'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Heur_1heurfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Heur_heurfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__363)); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur, __pyx_n_s_heurfree, __pyx_t_2) < 0) __PYX_ERR(12, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Heur);
+
+  /* "src/pyscipopt/heuristic.pxi":11
+ *         pass
+ * 
+ *     def heurinit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes primal heuristic'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Heur_3heurinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Heur_heurinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__364)); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur, __pyx_n_s_heurinit, __pyx_t_2) < 0) __PYX_ERR(12, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Heur);
+
+  /* "src/pyscipopt/heuristic.pxi":15
+ *         pass
+ * 
+ *     def heurexit(self):             # <<<<<<<<<<<<<<
+ *         '''calls exit method of primal heuristic'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Heur_5heurexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Heur_heurexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__365)); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur, __pyx_n_s_heurexit, __pyx_t_2) < 0) __PYX_ERR(12, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Heur);
+
+  /* "src/pyscipopt/heuristic.pxi":19
+ *         pass
+ * 
+ *     def heurinitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs primal heuristic that the branch and bound process is being started'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Heur_7heurinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Heur_heurinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__366)); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur, __pyx_n_s_heurinitsol, __pyx_t_2) < 0) __PYX_ERR(12, 19, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Heur);
+
+  /* "src/pyscipopt/heuristic.pxi":23
+ *         pass
+ * 
+ *     def heurexitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs primal heuristic that the branch and bound process data is being freed'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Heur_9heurexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Heur_heurexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__367)); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur, __pyx_n_s_heurexitsol, __pyx_t_2) < 0) __PYX_ERR(12, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Heur);
+
+  /* "src/pyscipopt/heuristic.pxi":27
+ *         pass
+ * 
+ *     def heurexec(self, heurtiming, nodeinfeasible):             # <<<<<<<<<<<<<<
+ *         '''should the heuristic the executed at the given depth, frequency, timing,...'''
+ *         print("python error in heurexec: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Heur_11heurexec, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Heur_heurexec, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__369)); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 27, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur, __pyx_n_s_heurexec, __pyx_t_2) < 0) __PYX_ERR(12, 27, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Heur);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Heur_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Heur___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__370)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Heur);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Heur, (type(self), 0x48f811e, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Heur__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Heur_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Heur___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__371)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Heur, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Heur);
+
+  /* "src/pyscipopt/presol.pxi":6
+ *     cdef public Model model
+ * 
+ *     def presolfree(self):             # <<<<<<<<<<<<<<
+ *         '''frees memory of presolver'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Presol_1presolfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Presol_presolfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__372)); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol, __pyx_n_s_presolfree, __pyx_t_2) < 0) __PYX_ERR(13, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Presol);
+
+  /* "src/pyscipopt/presol.pxi":10
+ *         pass
+ * 
+ *     def presolinit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes presolver'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Presol_3presolinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Presol_presolinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__373)); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol, __pyx_n_s_presolinit, __pyx_t_2) < 0) __PYX_ERR(13, 10, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Presol);
+
+  /* "src/pyscipopt/presol.pxi":14
+ *         pass
+ * 
+ *     def presolexit(self):             # <<<<<<<<<<<<<<
+ *         '''deinitializes presolver'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Presol_5presolexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Presol_presolexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__374)); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol, __pyx_n_s_presolexit, __pyx_t_2) < 0) __PYX_ERR(13, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Presol);
+
+  /* "src/pyscipopt/presol.pxi":18
+ *         pass
+ * 
+ *     def presolinitpre(self):             # <<<<<<<<<<<<<<
+ *         '''informs presolver that the presolving process is being started'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Presol_7presolinitpre, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Presol_presolinitpre, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__375)); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol, __pyx_n_s_presolinitpre, __pyx_t_2) < 0) __PYX_ERR(13, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Presol);
+
+  /* "src/pyscipopt/presol.pxi":22
+ *         pass
+ * 
+ *     def presolexitpre(self):             # <<<<<<<<<<<<<<
+ *         '''informs presolver that the presolving process is finished'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Presol_9presolexitpre, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Presol_presolexitpre, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__376)); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol, __pyx_n_s_presolexitpre, __pyx_t_2) < 0) __PYX_ERR(13, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Presol);
+
+  /* "src/pyscipopt/presol.pxi":26
+ *         pass
+ * 
+ *     def presolexec(self, nrounds, presoltiming):             # <<<<<<<<<<<<<<
+ *         '''executes presolver'''
+ *         print("python error in presolexec: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Presol_11presolexec, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Presol_presolexec, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__378)); if (unlikely(!__pyx_t_2)) __PYX_ERR(13, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol, __pyx_n_s_presolexec, __pyx_t_2) < 0) __PYX_ERR(13, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Presol);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Presol_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Presol___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__379)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Presol);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Presol, (type(self), 0x9372c47, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Presol__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Presol_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Presol___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__380)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Presol, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Presol);
+
+  /* "src/pyscipopt/pricer.pxi":6
+ *     cdef public Model model
+ * 
+ *     def pricerfree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of variable pricer '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_1pricerfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer_pricerfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__381)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_pricerfree, __pyx_t_2) < 0) __PYX_ERR(14, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "src/pyscipopt/pricer.pxi":10
+ *         pass
+ * 
+ *     def pricerinit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes variable pricer'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_3pricerinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer_pricerinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__382)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_pricerinit, __pyx_t_2) < 0) __PYX_ERR(14, 10, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "src/pyscipopt/pricer.pxi":14
+ *         pass
+ * 
+ *     def pricerexit(self):             # <<<<<<<<<<<<<<
+ *         '''calls exit method of variable pricer'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_5pricerexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer_pricerexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__383)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_pricerexit, __pyx_t_2) < 0) __PYX_ERR(14, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "src/pyscipopt/pricer.pxi":18
+ *         pass
+ * 
+ *     def pricerinitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs variable pricer that the branch and bound process is being started '''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_7pricerinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer_pricerinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__384)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_pricerinitsol, __pyx_t_2) < 0) __PYX_ERR(14, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "src/pyscipopt/pricer.pxi":22
+ *         pass
+ * 
+ *     def pricerexitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs variable pricer that the branch and bound process data is being freed'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_9pricerexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer_pricerexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__385)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_pricerexitsol, __pyx_t_2) < 0) __PYX_ERR(14, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "src/pyscipopt/pricer.pxi":26
+ *         pass
+ * 
+ *     def pricerredcost(self):             # <<<<<<<<<<<<<<
+ *         '''calls reduced cost pricing method of variable pricer'''
+ *         raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_11pricerredcost, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer_pricerredcost, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__386)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_pricerredcost, __pyx_t_2) < 0) __PYX_ERR(14, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "src/pyscipopt/pricer.pxi":30
+ *         raise NotImplementedError("pricerredcost() is a fundamental callback and should be implemented in the derived class")
+ * 
+ *     def pricerfarkas(self):             # <<<<<<<<<<<<<<
+ *         '''calls Farkas pricing method of variable pricer'''
+ *         raise NotImplementedError("pricerfarkas() is a fundamental callback and should be implemented in the derived class")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_13pricerfarkas, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer_pricerfarkas, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__387)); if (unlikely(!__pyx_t_2)) __PYX_ERR(14, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_pricerfarkas, __pyx_t_2) < 0) __PYX_ERR(14, 30, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__388)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Pricer, (type(self), 0x9372c47, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Pricer__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Pricer_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Pricer___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__389)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Pricer, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Pricer);
+
+  /* "src/pyscipopt/propagator.pxi":6
+ *     cdef public Model model
+ * 
+ *     def propfree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of propagator'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_1propfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__390)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propfree, __pyx_t_2) < 0) __PYX_ERR(15, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":10
+ *         pass
+ * 
+ *     def propinit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes propagator'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_3propinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__391)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propinit, __pyx_t_2) < 0) __PYX_ERR(15, 10, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":14
+ *         pass
+ * 
+ *     def propexit(self):             # <<<<<<<<<<<<<<
+ *         '''calls exit method of propagator'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_5propexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__392)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propexit, __pyx_t_2) < 0) __PYX_ERR(15, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":18
+ *         pass
+ * 
+ *     def propinitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs propagator that the prop and bound process is being started'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_7propinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__393)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propinitsol, __pyx_t_2) < 0) __PYX_ERR(15, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":22
+ *         pass
+ * 
+ *     def propexitsol(self, restart):             # <<<<<<<<<<<<<<
+ *         '''informs propagator that the prop and bound process data is being freed'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_9propexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__395)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propexitsol, __pyx_t_2) < 0) __PYX_ERR(15, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":26
+ *         pass
+ * 
+ *     def propinitpre(self):             # <<<<<<<<<<<<<<
+ *         '''informs propagator that the presolving process is being started'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_11propinitpre, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propinitpre, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__396)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propinitpre, __pyx_t_2) < 0) __PYX_ERR(15, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":30
+ *         pass
+ * 
+ *     def propexitpre(self):             # <<<<<<<<<<<<<<
+ *         '''informs propagator that the presolving process is finished'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_13propexitpre, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propexitpre, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__397)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propexitpre, __pyx_t_2) < 0) __PYX_ERR(15, 30, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":34
+ *         pass
+ * 
+ *     def proppresol(self, nrounds, presoltiming, result_dict):             # <<<<<<<<<<<<<<
+ *         '''executes presolving method of propagator'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_15proppresol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_proppresol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__399)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_proppresol, __pyx_t_2) < 0) __PYX_ERR(15, 34, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":38
+ *         pass
+ * 
+ *     def propexec(self, proptiming):             # <<<<<<<<<<<<<<
+ *         '''calls execution method of propagator'''
+ *         print("python error in propexec: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_17propexec, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propexec, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__401)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propexec, __pyx_t_2) < 0) __PYX_ERR(15, 38, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/propagator.pxi":43
+ *         return {}
+ * 
+ *     def propresprop(self, confvar, inferinfo, bdtype, relaxedbd):             # <<<<<<<<<<<<<<
+ *         '''resolves the given conflicting bound, that was reduced by the given propagator'''
+ *         print("python error in propresprop: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_19propresprop, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop_propresprop, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__403)); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_propresprop, __pyx_t_2) < 0) __PYX_ERR(15, 43, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_21__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__404)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Prop, (type(self), 0x9372c47, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Prop__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Prop_23__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Prop___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__405)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Prop, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Prop);
+
+  /* "src/pyscipopt/sepa.pxi":7
+ *     cdef public str name
+ * 
+ *     def sepafree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of separator'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_1sepafree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa_sepafree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__406)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_sepafree, __pyx_t_2) < 0) __PYX_ERR(16, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "src/pyscipopt/sepa.pxi":11
+ *         pass
+ * 
+ *     def sepainit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes separator'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_3sepainit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa_sepainit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__407)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_sepainit, __pyx_t_2) < 0) __PYX_ERR(16, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "src/pyscipopt/sepa.pxi":15
+ *         pass
+ * 
+ *     def sepaexit(self):             # <<<<<<<<<<<<<<
+ *         '''calls exit method of separator'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_5sepaexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa_sepaexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__408)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_sepaexit, __pyx_t_2) < 0) __PYX_ERR(16, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "src/pyscipopt/sepa.pxi":19
+ *         pass
+ * 
+ *     def sepainitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs separator that the branch and bound process is being started'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_7sepainitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa_sepainitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__409)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_sepainitsol, __pyx_t_2) < 0) __PYX_ERR(16, 19, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "src/pyscipopt/sepa.pxi":23
+ *         pass
+ * 
+ *     def sepaexitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs separator that the branch and bound process data is being freed'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_9sepaexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa_sepaexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__410)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_sepaexitsol, __pyx_t_2) < 0) __PYX_ERR(16, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "src/pyscipopt/sepa.pxi":27
+ *         pass
+ * 
+ *     def sepaexeclp(self):             # <<<<<<<<<<<<<<
+ *         '''calls LP separation method of separator'''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_11sepaexeclp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa_sepaexeclp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__411)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 27, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_sepaexeclp, __pyx_t_2) < 0) __PYX_ERR(16, 27, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "src/pyscipopt/sepa.pxi":31
+ *         return {}
+ * 
+ *     def sepaexecsol(self, solution):             # <<<<<<<<<<<<<<
+ *         '''calls primal solution separation method of separator'''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_13sepaexecsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa_sepaexecsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__413)); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_sepaexecsol, __pyx_t_2) < 0) __PYX_ERR(16, 31, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__414)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Sepa, (type(self), 0x48f811e, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Sepa__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Sepa_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Sepa___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__415)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Sepa, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Sepa);
+
+  /* "src/pyscipopt/reader.pxi":7
+ *     cdef public str name
+ * 
+ *     def readerfree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of reader'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Reader_1readerfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Reader_readerfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__416)); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Reader, __pyx_n_s_readerfree, __pyx_t_2) < 0) __PYX_ERR(17, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Reader);
+
+  /* "src/pyscipopt/reader.pxi":11
+ *         pass
+ * 
+ *     def readerread(self, filename):             # <<<<<<<<<<<<<<
+ *         '''calls read method of reader'''
+ *         return {}
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Reader_3readerread, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Reader_readerread, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__417)); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Reader, __pyx_n_s_readerread, __pyx_t_2) < 0) __PYX_ERR(17, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Reader);
+
+  /* "src/pyscipopt/reader.pxi":15
+ *         return {}
+ * 
+ *     def readerwrite(self, file, name, transformed, objsense, objscale, objoffset, binvars, intvars,             # <<<<<<<<<<<<<<
+ *                     implvars, contvars, fixedvars, startnvars, conss, maxnconss, startnconss, genericnames):
+ *         '''calls write method of reader'''
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Reader_5readerwrite, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Reader_readerwrite, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__419)); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Reader, __pyx_n_s_readerwrite, __pyx_t_2) < 0) __PYX_ERR(17, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Reader);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Reader_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Reader___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__420)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Reader, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Reader);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Reader, (type(self), 0x48f811e, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Reader__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Reader_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Reader___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__421)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Reader, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Reader);
+
+  /* "src/pyscipopt/relax.pxi":7
+ *     cdef public str name
+ * 
+ *     def relaxfree(self):             # <<<<<<<<<<<<<<
+ *         '''calls destructor and frees memory of relaxation handler'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Relax_1relaxfree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Relax_relaxfree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__422)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 7, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax, __pyx_n_s_relaxfree, __pyx_t_2) < 0) __PYX_ERR(18, 7, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Relax);
+
+  /* "src/pyscipopt/relax.pxi":11
+ *         pass
+ * 
+ *     def relaxinit(self):             # <<<<<<<<<<<<<<
+ *         '''initializes relaxation handler'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Relax_3relaxinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Relax_relaxinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__423)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax, __pyx_n_s_relaxinit, __pyx_t_2) < 0) __PYX_ERR(18, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Relax);
+
+  /* "src/pyscipopt/relax.pxi":15
+ *         pass
+ * 
+ *     def relaxexit(self):             # <<<<<<<<<<<<<<
+ *         '''calls exit method of relaxation handler'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Relax_5relaxexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Relax_relaxexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__424)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 15, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax, __pyx_n_s_relaxexit, __pyx_t_2) < 0) __PYX_ERR(18, 15, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Relax);
+
+  /* "src/pyscipopt/relax.pxi":19
+ *         pass
+ * 
+ *     def relaxinitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs relaxaton handler that the branch and bound process is being started'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Relax_7relaxinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Relax_relaxinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__425)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 19, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax, __pyx_n_s_relaxinitsol, __pyx_t_2) < 0) __PYX_ERR(18, 19, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Relax);
+
+  /* "src/pyscipopt/relax.pxi":23
+ *         pass
+ * 
+ *     def relaxexitsol(self):             # <<<<<<<<<<<<<<
+ *         '''informs relaxation handler that the branch and bound process data is being freed'''
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Relax_9relaxexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Relax_relaxexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__426)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax, __pyx_n_s_relaxexitsol, __pyx_t_2) < 0) __PYX_ERR(18, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Relax);
+
+  /* "src/pyscipopt/relax.pxi":27
+ *         pass
+ * 
+ *     def relaxexec(self):             # <<<<<<<<<<<<<<
+ *         '''callls execution method of relaxation handler'''
+ *         print("python error in relaxexec: this method needs to be implemented")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Relax_11relaxexec, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Relax_relaxexec, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__427)); if (unlikely(!__pyx_t_2)) __PYX_ERR(18, 27, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax, __pyx_n_s_relaxexec, __pyx_t_2) < 0) __PYX_ERR(18, 27, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Relax);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Relax_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Relax___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__428)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Relax);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Relax, (type(self), 0x48f811e, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Relax__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Relax_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Relax___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__429)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Relax, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Relax);
+
+  /* "src/pyscipopt/nodesel.pxi":6
+ *   cdef public Model model
+ * 
+ *   def nodefree(self):             # <<<<<<<<<<<<<<
+ *     '''frees memory of node selector'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_1nodefree, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel_nodefree, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__430)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_nodefree, __pyx_t_2) < 0) __PYX_ERR(19, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "src/pyscipopt/nodesel.pxi":10
+ *     pass
+ * 
+ *   def nodeinit(self):             # <<<<<<<<<<<<<<
+ *     ''' executed after the problem is transformed. use this call to initialize node selector data.'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_3nodeinit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel_nodeinit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__431)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 10, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_nodeinit, __pyx_t_2) < 0) __PYX_ERR(19, 10, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "src/pyscipopt/nodesel.pxi":14
+ *     pass
+ * 
+ *   def nodeexit(self):             # <<<<<<<<<<<<<<
+ *     '''executed before the transformed problem is freed'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_5nodeexit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel_nodeexit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__432)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 14, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_nodeexit, __pyx_t_2) < 0) __PYX_ERR(19, 14, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "src/pyscipopt/nodesel.pxi":18
+ *     pass
+ * 
+ *   def nodeinitsol(self):             # <<<<<<<<<<<<<<
+ *     '''executed when the presolving is finished and the branch-and-bound process is about to begin'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_7nodeinitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel_nodeinitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__433)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_nodeinitsol, __pyx_t_2) < 0) __PYX_ERR(19, 18, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "src/pyscipopt/nodesel.pxi":22
+ *     pass
+ * 
+ *   def nodeexitsol(self):             # <<<<<<<<<<<<<<
+ *     '''executed before the branch-and-bound process is freed'''
+ *     pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_9nodeexitsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel_nodeexitsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__434)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_nodeexitsol, __pyx_t_2) < 0) __PYX_ERR(19, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "src/pyscipopt/nodesel.pxi":26
+ *     pass
+ * 
+ *   def nodeselect(self):             # <<<<<<<<<<<<<<
+ *     '''first method called in each iteration in the main solving loop. '''
+ *     # this method needs to be implemented by the user
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_11nodeselect, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel_nodeselect, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__435)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_nodeselect, __pyx_t_2) < 0) __PYX_ERR(19, 26, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "src/pyscipopt/nodesel.pxi":31
+ *     return {}
+ * 
+ *   def nodecomp(self, node1, node2):             # <<<<<<<<<<<<<<
+ *     '''
+ *     compare two leaves of the current branching tree
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_13nodecomp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel_nodecomp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__437)); if (unlikely(!__pyx_t_2)) __PYX_ERR(19, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_nodecomp, __pyx_t_2) < 0) __PYX_ERR(19, 31, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__438)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_Nodesel, (type(self), 0x9372c47, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_Nodesel__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_7Nodesel_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Nodesel___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__439)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Nodesel, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Nodesel);
+
+  /* "src/pyscipopt/scip.pxi":39
+ * 
+ * # recommended SCIP version; major version is required
+ * MAJOR = 9             # <<<<<<<<<<<<<<
+ * MINOR = 0
+ * PATCH = 0
+ */
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MAJOR, __pyx_int_9) < 0) __PYX_ERR(0, 39, __pyx_L1_error)
+
+  /* "src/pyscipopt/scip.pxi":40
+ * # recommended SCIP version; major version is required
+ * MAJOR = 9
+ * MINOR = 0             # <<<<<<<<<<<<<<
+ * PATCH = 0
+ * 
+ */
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINOR, __pyx_int_0) < 0) __PYX_ERR(0, 40, __pyx_L1_error)
+
+  /* "src/pyscipopt/scip.pxi":41
+ * MAJOR = 9
+ * MINOR = 0
+ * PATCH = 0             # <<<<<<<<<<<<<<
+ * 
+ * # for external user functions use def; for functions used only inside the interface (starting with _) use cdef
+ */
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PATCH, __pyx_int_0) < 0) __PYX_ERR(0, 41, __pyx_L1_error)
+
+  /* "src/pyscipopt/scip.pxi":46
+ * # todo: check whether this is currently done like this
+ * 
+ * if sys.version_info >= (3, 0):             # <<<<<<<<<<<<<<
+ *     str_conversion = lambda x:bytes(x,'utf-8')
+ * else:
+ */
+  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_version_info); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_tuple__440, Py_GE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 46, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__pyx_t_8) {
+
+    /* "src/pyscipopt/scip.pxi":47
+ * 
+ * if sys.version_info >= (3, 0):
+ *     str_conversion = lambda x:bytes(x,'utf-8')             # <<<<<<<<<<<<<<
+ * else:
+ *     str_conversion = lambda x:x
+ */
+    __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_76lambda7, 0, __pyx_n_s_lambda, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 47, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (PyDict_SetItem(__pyx_d, __pyx_n_s_str_conversion, __pyx_t_2) < 0) __PYX_ERR(0, 47, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+    /* "src/pyscipopt/scip.pxi":46
+ * # todo: check whether this is currently done like this
+ * 
+ * if sys.version_info >= (3, 0):             # <<<<<<<<<<<<<<
+ *     str_conversion = lambda x:bytes(x,'utf-8')
+ * else:
+ */
+    goto __pyx_L2;
+  }
+
+  /* "src/pyscipopt/scip.pxi":49
+ *     str_conversion = lambda x:bytes(x,'utf-8')
+ * else:
+ *     str_conversion = lambda x:x             # <<<<<<<<<<<<<<
+ * 
+ * _SCIP_BOUNDTYPE_TO_STRING = {SCIP_BOUNDTYPE_UPPER: '<=',
+ */
+  /*else*/ {
+    __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_77lambda8, 0, __pyx_n_s_lambda, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    if (PyDict_SetItem(__pyx_d, __pyx_n_s_str_conversion, __pyx_t_2) < 0) __PYX_ERR(0, 49, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  }
+  __pyx_L2:;
+
+  /* "src/pyscipopt/scip.pxi":51
+ *     str_conversion = lambda x:x
+ * 
+ * _SCIP_BOUNDTYPE_TO_STRING = {SCIP_BOUNDTYPE_UPPER: '<=',             # <<<<<<<<<<<<<<
+ *                              SCIP_BOUNDTYPE_LOWER: '>='}
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_SCIP_BOUNDTYPE(SCIP_BOUNDTYPE_UPPER); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_t_3, __pyx_kp_u__441) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "src/pyscipopt/scip.pxi":52
+ * 
+ * _SCIP_BOUNDTYPE_TO_STRING = {SCIP_BOUNDTYPE_UPPER: '<=',
+ *                              SCIP_BOUNDTYPE_LOWER: '>='}             # <<<<<<<<<<<<<<
+ * 
+ * # Mapping the SCIP_RESULT enum to a python class
+ */
+  __pyx_t_3 = __Pyx_PyInt_From_SCIP_BOUNDTYPE(SCIP_BOUNDTYPE_LOWER); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_t_3, __pyx_kp_u__442) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SCIP_BOUNDTYPE_TO_STRING, __pyx_t_2) < 0) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":59
+ * # original naming scheme using capital letters
+ * cdef class PY_SCIP_RESULT:
+ *     DIDNOTRUN   = SCIP_DIDNOTRUN             # <<<<<<<<<<<<<<
+ *     DELAYED     = SCIP_DELAYED
+ *     DIDNOTFIND  = SCIP_DIDNOTFIND
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_DIDNOTRUN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_DIDNOTRUN, __pyx_t_2) < 0) __PYX_ERR(0, 59, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":60
+ * cdef class PY_SCIP_RESULT:
+ *     DIDNOTRUN   = SCIP_DIDNOTRUN
+ *     DELAYED     = SCIP_DELAYED             # <<<<<<<<<<<<<<
+ *     DIDNOTFIND  = SCIP_DIDNOTFIND
+ *     FEASIBLE    = SCIP_FEASIBLE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_DELAYED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_DELAYED, __pyx_t_2) < 0) __PYX_ERR(0, 60, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":61
+ *     DIDNOTRUN   = SCIP_DIDNOTRUN
+ *     DELAYED     = SCIP_DELAYED
+ *     DIDNOTFIND  = SCIP_DIDNOTFIND             # <<<<<<<<<<<<<<
+ *     FEASIBLE    = SCIP_FEASIBLE
+ *     INFEASIBLE  = SCIP_INFEASIBLE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_DIDNOTFIND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_DIDNOTFIND, __pyx_t_2) < 0) __PYX_ERR(0, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":62
+ *     DELAYED     = SCIP_DELAYED
+ *     DIDNOTFIND  = SCIP_DIDNOTFIND
+ *     FEASIBLE    = SCIP_FEASIBLE             # <<<<<<<<<<<<<<
+ *     INFEASIBLE  = SCIP_INFEASIBLE
+ *     UNBOUNDED   = SCIP_UNBOUNDED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_FEASIBLE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_FEASIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 62, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":63
+ *     DIDNOTFIND  = SCIP_DIDNOTFIND
+ *     FEASIBLE    = SCIP_FEASIBLE
+ *     INFEASIBLE  = SCIP_INFEASIBLE             # <<<<<<<<<<<<<<
+ *     UNBOUNDED   = SCIP_UNBOUNDED
+ *     CUTOFF      = SCIP_CUTOFF
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_INFEASIBLE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_INFEASIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":64
+ *     FEASIBLE    = SCIP_FEASIBLE
+ *     INFEASIBLE  = SCIP_INFEASIBLE
+ *     UNBOUNDED   = SCIP_UNBOUNDED             # <<<<<<<<<<<<<<
+ *     CUTOFF      = SCIP_CUTOFF
+ *     SEPARATED   = SCIP_SEPARATED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_UNBOUNDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_UNBOUNDED, __pyx_t_2) < 0) __PYX_ERR(0, 64, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":65
+ *     INFEASIBLE  = SCIP_INFEASIBLE
+ *     UNBOUNDED   = SCIP_UNBOUNDED
+ *     CUTOFF      = SCIP_CUTOFF             # <<<<<<<<<<<<<<
+ *     SEPARATED   = SCIP_SEPARATED
+ *     NEWROUND    = SCIP_NEWROUND
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_CUTOFF); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_CUTOFF, __pyx_t_2) < 0) __PYX_ERR(0, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":66
+ *     UNBOUNDED   = SCIP_UNBOUNDED
+ *     CUTOFF      = SCIP_CUTOFF
+ *     SEPARATED   = SCIP_SEPARATED             # <<<<<<<<<<<<<<
+ *     NEWROUND    = SCIP_NEWROUND
+ *     REDUCEDDOM  = SCIP_REDUCEDDOM
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_SEPARATED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_SEPARATED, __pyx_t_2) < 0) __PYX_ERR(0, 66, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":67
+ *     CUTOFF      = SCIP_CUTOFF
+ *     SEPARATED   = SCIP_SEPARATED
+ *     NEWROUND    = SCIP_NEWROUND             # <<<<<<<<<<<<<<
+ *     REDUCEDDOM  = SCIP_REDUCEDDOM
+ *     CONSADDED   = SCIP_CONSADDED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_NEWROUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_NEWROUND, __pyx_t_2) < 0) __PYX_ERR(0, 67, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":68
+ *     SEPARATED   = SCIP_SEPARATED
+ *     NEWROUND    = SCIP_NEWROUND
+ *     REDUCEDDOM  = SCIP_REDUCEDDOM             # <<<<<<<<<<<<<<
+ *     CONSADDED   = SCIP_CONSADDED
+ *     CONSCHANGED = SCIP_CONSCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_REDUCEDDOM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_REDUCEDDOM, __pyx_t_2) < 0) __PYX_ERR(0, 68, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":69
+ *     NEWROUND    = SCIP_NEWROUND
+ *     REDUCEDDOM  = SCIP_REDUCEDDOM
+ *     CONSADDED   = SCIP_CONSADDED             # <<<<<<<<<<<<<<
+ *     CONSCHANGED = SCIP_CONSCHANGED
+ *     BRANCHED    = SCIP_BRANCHED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_CONSADDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_CONSADDED, __pyx_t_2) < 0) __PYX_ERR(0, 69, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":70
+ *     REDUCEDDOM  = SCIP_REDUCEDDOM
+ *     CONSADDED   = SCIP_CONSADDED
+ *     CONSCHANGED = SCIP_CONSCHANGED             # <<<<<<<<<<<<<<
+ *     BRANCHED    = SCIP_BRANCHED
+ *     SOLVELP     = SCIP_SOLVELP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_CONSCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_CONSCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 70, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":71
+ *     CONSADDED   = SCIP_CONSADDED
+ *     CONSCHANGED = SCIP_CONSCHANGED
+ *     BRANCHED    = SCIP_BRANCHED             # <<<<<<<<<<<<<<
+ *     SOLVELP     = SCIP_SOLVELP
+ *     FOUNDSOL    = SCIP_FOUNDSOL
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_BRANCHED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_BRANCHED, __pyx_t_2) < 0) __PYX_ERR(0, 71, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":72
+ *     CONSCHANGED = SCIP_CONSCHANGED
+ *     BRANCHED    = SCIP_BRANCHED
+ *     SOLVELP     = SCIP_SOLVELP             # <<<<<<<<<<<<<<
+ *     FOUNDSOL    = SCIP_FOUNDSOL
+ *     SUSPENDED   = SCIP_SUSPENDED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_SOLVELP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_SOLVELP, __pyx_t_2) < 0) __PYX_ERR(0, 72, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":73
+ *     BRANCHED    = SCIP_BRANCHED
+ *     SOLVELP     = SCIP_SOLVELP
+ *     FOUNDSOL    = SCIP_FOUNDSOL             # <<<<<<<<<<<<<<
+ *     SUSPENDED   = SCIP_SUSPENDED
+ *     SUCCESS     = SCIP_SUCCESS
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_FOUNDSOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_FOUNDSOL, __pyx_t_2) < 0) __PYX_ERR(0, 73, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":74
+ *     SOLVELP     = SCIP_SOLVELP
+ *     FOUNDSOL    = SCIP_FOUNDSOL
+ *     SUSPENDED   = SCIP_SUSPENDED             # <<<<<<<<<<<<<<
+ *     SUCCESS     = SCIP_SUCCESS
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_SUSPENDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_SUSPENDED, __pyx_t_2) < 0) __PYX_ERR(0, 74, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":75
+ *     FOUNDSOL    = SCIP_FOUNDSOL
+ *     SUSPENDED   = SCIP_SUSPENDED
+ *     SUCCESS     = SCIP_SUCCESS             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_PARAMSETTING:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_RESULT(SCIP_SUCCESS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_SUCCESS, __pyx_t_2) < 0) __PYX_ERR(0, 75, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_14PY_SCIP_RESULT_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_RESULT___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__443)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_RESULT, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_RESULT__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_14PY_SCIP_RESULT_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_RESULT___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__444)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_RESULT);
+
+  /* "src/pyscipopt/scip.pxi":78
+ * 
+ * cdef class PY_SCIP_PARAMSETTING:
+ *     DEFAULT     = SCIP_PARAMSETTING_DEFAULT             # <<<<<<<<<<<<<<
+ *     AGGRESSIVE  = SCIP_PARAMSETTING_AGGRESSIVE
+ *     FAST        = SCIP_PARAMSETTING_FAST
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMSETTING(SCIP_PARAMSETTING_DEFAULT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, __pyx_n_s_DEFAULT, __pyx_t_2) < 0) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING);
+
+  /* "src/pyscipopt/scip.pxi":79
+ * cdef class PY_SCIP_PARAMSETTING:
+ *     DEFAULT     = SCIP_PARAMSETTING_DEFAULT
+ *     AGGRESSIVE  = SCIP_PARAMSETTING_AGGRESSIVE             # <<<<<<<<<<<<<<
+ *     FAST        = SCIP_PARAMSETTING_FAST
+ *     OFF         = SCIP_PARAMSETTING_OFF
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMSETTING(SCIP_PARAMSETTING_AGGRESSIVE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, __pyx_n_s_AGGRESSIVE, __pyx_t_2) < 0) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING);
+
+  /* "src/pyscipopt/scip.pxi":80
+ *     DEFAULT     = SCIP_PARAMSETTING_DEFAULT
+ *     AGGRESSIVE  = SCIP_PARAMSETTING_AGGRESSIVE
+ *     FAST        = SCIP_PARAMSETTING_FAST             # <<<<<<<<<<<<<<
+ *     OFF         = SCIP_PARAMSETTING_OFF
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMSETTING(SCIP_PARAMSETTING_FAST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, __pyx_n_s_FAST, __pyx_t_2) < 0) __PYX_ERR(0, 80, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING);
+
+  /* "src/pyscipopt/scip.pxi":81
+ *     AGGRESSIVE  = SCIP_PARAMSETTING_AGGRESSIVE
+ *     FAST        = SCIP_PARAMSETTING_FAST
+ *     OFF         = SCIP_PARAMSETTING_OFF             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_PARAMEMPHASIS:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMSETTING(SCIP_PARAMSETTING_OFF); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, __pyx_n_s_OFF, __pyx_t_2) < 0) __PYX_ERR(0, 81, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_PARAMSETTING___reduce_cy, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__445)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_PARAMSETTING, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_PARAMSETTING__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_20PY_SCIP_PARAMSETTING_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_PARAMSETTING___setstate, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__446)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMSETTING);
+
+  /* "src/pyscipopt/scip.pxi":84
+ * 
+ * cdef class PY_SCIP_PARAMEMPHASIS:
+ *     DEFAULT      = SCIP_PARAMEMPHASIS_DEFAULT             # <<<<<<<<<<<<<<
+ *     CPSOLVER     = SCIP_PARAMEMPHASIS_CPSOLVER
+ *     EASYCIP      = SCIP_PARAMEMPHASIS_EASYCIP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_DEFAULT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_DEFAULT, __pyx_t_2) < 0) __PYX_ERR(0, 84, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":85
+ * cdef class PY_SCIP_PARAMEMPHASIS:
+ *     DEFAULT      = SCIP_PARAMEMPHASIS_DEFAULT
+ *     CPSOLVER     = SCIP_PARAMEMPHASIS_CPSOLVER             # <<<<<<<<<<<<<<
+ *     EASYCIP      = SCIP_PARAMEMPHASIS_EASYCIP
+ *     FEASIBILITY  = SCIP_PARAMEMPHASIS_FEASIBILITY
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_CPSOLVER); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_CPSOLVER, __pyx_t_2) < 0) __PYX_ERR(0, 85, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":86
+ *     DEFAULT      = SCIP_PARAMEMPHASIS_DEFAULT
+ *     CPSOLVER     = SCIP_PARAMEMPHASIS_CPSOLVER
+ *     EASYCIP      = SCIP_PARAMEMPHASIS_EASYCIP             # <<<<<<<<<<<<<<
+ *     FEASIBILITY  = SCIP_PARAMEMPHASIS_FEASIBILITY
+ *     HARDLP       = SCIP_PARAMEMPHASIS_HARDLP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_EASYCIP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_EASYCIP, __pyx_t_2) < 0) __PYX_ERR(0, 86, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":87
+ *     CPSOLVER     = SCIP_PARAMEMPHASIS_CPSOLVER
+ *     EASYCIP      = SCIP_PARAMEMPHASIS_EASYCIP
+ *     FEASIBILITY  = SCIP_PARAMEMPHASIS_FEASIBILITY             # <<<<<<<<<<<<<<
+ *     HARDLP       = SCIP_PARAMEMPHASIS_HARDLP
+ *     OPTIMALITY   = SCIP_PARAMEMPHASIS_OPTIMALITY
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_FEASIBILITY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_FEASIBILITY, __pyx_t_2) < 0) __PYX_ERR(0, 87, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":88
+ *     EASYCIP      = SCIP_PARAMEMPHASIS_EASYCIP
+ *     FEASIBILITY  = SCIP_PARAMEMPHASIS_FEASIBILITY
+ *     HARDLP       = SCIP_PARAMEMPHASIS_HARDLP             # <<<<<<<<<<<<<<
+ *     OPTIMALITY   = SCIP_PARAMEMPHASIS_OPTIMALITY
+ *     COUNTER      = SCIP_PARAMEMPHASIS_COUNTER
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_HARDLP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_HARDLP, __pyx_t_2) < 0) __PYX_ERR(0, 88, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":89
+ *     FEASIBILITY  = SCIP_PARAMEMPHASIS_FEASIBILITY
+ *     HARDLP       = SCIP_PARAMEMPHASIS_HARDLP
+ *     OPTIMALITY   = SCIP_PARAMEMPHASIS_OPTIMALITY             # <<<<<<<<<<<<<<
+ *     COUNTER      = SCIP_PARAMEMPHASIS_COUNTER
+ *     PHASEFEAS    = SCIP_PARAMEMPHASIS_PHASEFEAS
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_OPTIMALITY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_OPTIMALITY, __pyx_t_2) < 0) __PYX_ERR(0, 89, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":90
+ *     HARDLP       = SCIP_PARAMEMPHASIS_HARDLP
+ *     OPTIMALITY   = SCIP_PARAMEMPHASIS_OPTIMALITY
+ *     COUNTER      = SCIP_PARAMEMPHASIS_COUNTER             # <<<<<<<<<<<<<<
+ *     PHASEFEAS    = SCIP_PARAMEMPHASIS_PHASEFEAS
+ *     PHASEIMPROVE = SCIP_PARAMEMPHASIS_PHASEIMPROVE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_COUNTER); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_COUNTER, __pyx_t_2) < 0) __PYX_ERR(0, 90, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":91
+ *     OPTIMALITY   = SCIP_PARAMEMPHASIS_OPTIMALITY
+ *     COUNTER      = SCIP_PARAMEMPHASIS_COUNTER
+ *     PHASEFEAS    = SCIP_PARAMEMPHASIS_PHASEFEAS             # <<<<<<<<<<<<<<
+ *     PHASEIMPROVE = SCIP_PARAMEMPHASIS_PHASEIMPROVE
+ *     PHASEPROOF   = SCIP_PARAMEMPHASIS_PHASEPROOF
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_PHASEFEAS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_PHASEFEAS, __pyx_t_2) < 0) __PYX_ERR(0, 91, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":92
+ *     COUNTER      = SCIP_PARAMEMPHASIS_COUNTER
+ *     PHASEFEAS    = SCIP_PARAMEMPHASIS_PHASEFEAS
+ *     PHASEIMPROVE = SCIP_PARAMEMPHASIS_PHASEIMPROVE             # <<<<<<<<<<<<<<
+ *     PHASEPROOF   = SCIP_PARAMEMPHASIS_PHASEPROOF
+ *     NUMERICS     = SCIP_PARAMEMPHASIS_NUMERICS
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_PHASEIMPROVE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_PHASEIMPROVE, __pyx_t_2) < 0) __PYX_ERR(0, 92, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":93
+ *     PHASEFEAS    = SCIP_PARAMEMPHASIS_PHASEFEAS
+ *     PHASEIMPROVE = SCIP_PARAMEMPHASIS_PHASEIMPROVE
+ *     PHASEPROOF   = SCIP_PARAMEMPHASIS_PHASEPROOF             # <<<<<<<<<<<<<<
+ *     NUMERICS     = SCIP_PARAMEMPHASIS_NUMERICS
+ *     BENCHMARK    = SCIP_PARAMEMPHASIS_BENCHMARK
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_PHASEPROOF); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_PHASEPROOF, __pyx_t_2) < 0) __PYX_ERR(0, 93, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":94
+ *     PHASEIMPROVE = SCIP_PARAMEMPHASIS_PHASEIMPROVE
+ *     PHASEPROOF   = SCIP_PARAMEMPHASIS_PHASEPROOF
+ *     NUMERICS     = SCIP_PARAMEMPHASIS_NUMERICS             # <<<<<<<<<<<<<<
+ *     BENCHMARK    = SCIP_PARAMEMPHASIS_BENCHMARK
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_NUMERICS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_NUMERICS, __pyx_t_2) < 0) __PYX_ERR(0, 94, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":95
+ *     PHASEPROOF   = SCIP_PARAMEMPHASIS_PHASEPROOF
+ *     NUMERICS     = SCIP_PARAMEMPHASIS_NUMERICS
+ *     BENCHMARK    = SCIP_PARAMEMPHASIS_BENCHMARK             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_STATUS:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS_BENCHMARK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_BENCHMARK, __pyx_t_2) < 0) __PYX_ERR(0, 95, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_PARAMEMPHASIS___reduce_c, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__447)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_PARAMEMPHASIS, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_21PY_SCIP_PARAMEMPHASIS_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_PARAMEMPHASIS___setstate, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__448)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PARAMEMPHASIS);
+
+  /* "src/pyscipopt/scip.pxi":98
+ * 
+ * cdef class PY_SCIP_STATUS:
+ *     UNKNOWN        = SCIP_STATUS_UNKNOWN             # <<<<<<<<<<<<<<
+ *     USERINTERRUPT  = SCIP_STATUS_USERINTERRUPT
+ *     NODELIMIT      = SCIP_STATUS_NODELIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_UNKNOWN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_UNKNOWN, __pyx_t_2) < 0) __PYX_ERR(0, 98, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":99
+ * cdef class PY_SCIP_STATUS:
+ *     UNKNOWN        = SCIP_STATUS_UNKNOWN
+ *     USERINTERRUPT  = SCIP_STATUS_USERINTERRUPT             # <<<<<<<<<<<<<<
+ *     NODELIMIT      = SCIP_STATUS_NODELIMIT
+ *     TOTALNODELIMIT = SCIP_STATUS_TOTALNODELIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_USERINTERRUPT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_USERINTERRUPT, __pyx_t_2) < 0) __PYX_ERR(0, 99, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":100
+ *     UNKNOWN        = SCIP_STATUS_UNKNOWN
+ *     USERINTERRUPT  = SCIP_STATUS_USERINTERRUPT
+ *     NODELIMIT      = SCIP_STATUS_NODELIMIT             # <<<<<<<<<<<<<<
+ *     TOTALNODELIMIT = SCIP_STATUS_TOTALNODELIMIT
+ *     STALLNODELIMIT = SCIP_STATUS_STALLNODELIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_NODELIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 100, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_NODELIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 100, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":101
+ *     USERINTERRUPT  = SCIP_STATUS_USERINTERRUPT
+ *     NODELIMIT      = SCIP_STATUS_NODELIMIT
+ *     TOTALNODELIMIT = SCIP_STATUS_TOTALNODELIMIT             # <<<<<<<<<<<<<<
+ *     STALLNODELIMIT = SCIP_STATUS_STALLNODELIMIT
+ *     TIMELIMIT      = SCIP_STATUS_TIMELIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_TOTALNODELIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_TOTALNODELIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 101, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":102
+ *     NODELIMIT      = SCIP_STATUS_NODELIMIT
+ *     TOTALNODELIMIT = SCIP_STATUS_TOTALNODELIMIT
+ *     STALLNODELIMIT = SCIP_STATUS_STALLNODELIMIT             # <<<<<<<<<<<<<<
+ *     TIMELIMIT      = SCIP_STATUS_TIMELIMIT
+ *     MEMLIMIT       = SCIP_STATUS_MEMLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_STALLNODELIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_STALLNODELIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 102, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":103
+ *     TOTALNODELIMIT = SCIP_STATUS_TOTALNODELIMIT
+ *     STALLNODELIMIT = SCIP_STATUS_STALLNODELIMIT
+ *     TIMELIMIT      = SCIP_STATUS_TIMELIMIT             # <<<<<<<<<<<<<<
+ *     MEMLIMIT       = SCIP_STATUS_MEMLIMIT
+ *     GAPLIMIT       = SCIP_STATUS_GAPLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_TIMELIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 103, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_TIMELIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 103, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":104
+ *     STALLNODELIMIT = SCIP_STATUS_STALLNODELIMIT
+ *     TIMELIMIT      = SCIP_STATUS_TIMELIMIT
+ *     MEMLIMIT       = SCIP_STATUS_MEMLIMIT             # <<<<<<<<<<<<<<
+ *     GAPLIMIT       = SCIP_STATUS_GAPLIMIT
+ *     SOLLIMIT       = SCIP_STATUS_SOLLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_MEMLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_MEMLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 104, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":105
+ *     TIMELIMIT      = SCIP_STATUS_TIMELIMIT
+ *     MEMLIMIT       = SCIP_STATUS_MEMLIMIT
+ *     GAPLIMIT       = SCIP_STATUS_GAPLIMIT             # <<<<<<<<<<<<<<
+ *     SOLLIMIT       = SCIP_STATUS_SOLLIMIT
+ *     BESTSOLLIMIT   = SCIP_STATUS_BESTSOLLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_GAPLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_GAPLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 105, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":106
+ *     MEMLIMIT       = SCIP_STATUS_MEMLIMIT
+ *     GAPLIMIT       = SCIP_STATUS_GAPLIMIT
+ *     SOLLIMIT       = SCIP_STATUS_SOLLIMIT             # <<<<<<<<<<<<<<
+ *     BESTSOLLIMIT   = SCIP_STATUS_BESTSOLLIMIT
+ *     RESTARTLIMIT   = SCIP_STATUS_RESTARTLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_SOLLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_SOLLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":107
+ *     GAPLIMIT       = SCIP_STATUS_GAPLIMIT
+ *     SOLLIMIT       = SCIP_STATUS_SOLLIMIT
+ *     BESTSOLLIMIT   = SCIP_STATUS_BESTSOLLIMIT             # <<<<<<<<<<<<<<
+ *     RESTARTLIMIT   = SCIP_STATUS_RESTARTLIMIT
+ *     PRIMALLIMIT    = SCIP_STATUS_PRIMALLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_BESTSOLLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_BESTSOLLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 107, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":108
+ *     SOLLIMIT       = SCIP_STATUS_SOLLIMIT
+ *     BESTSOLLIMIT   = SCIP_STATUS_BESTSOLLIMIT
+ *     RESTARTLIMIT   = SCIP_STATUS_RESTARTLIMIT             # <<<<<<<<<<<<<<
+ *     PRIMALLIMIT    = SCIP_STATUS_PRIMALLIMIT
+ *     DUALLIMIT      = SCIP_STATUS_DUALLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_RESTARTLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_RESTARTLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 108, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":109
+ *     BESTSOLLIMIT   = SCIP_STATUS_BESTSOLLIMIT
+ *     RESTARTLIMIT   = SCIP_STATUS_RESTARTLIMIT
+ *     PRIMALLIMIT    = SCIP_STATUS_PRIMALLIMIT             # <<<<<<<<<<<<<<
+ *     DUALLIMIT      = SCIP_STATUS_DUALLIMIT
+ *     OPTIMAL        = SCIP_STATUS_OPTIMAL
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_PRIMALLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_PRIMALLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 109, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":110
+ *     RESTARTLIMIT   = SCIP_STATUS_RESTARTLIMIT
+ *     PRIMALLIMIT    = SCIP_STATUS_PRIMALLIMIT
+ *     DUALLIMIT      = SCIP_STATUS_DUALLIMIT             # <<<<<<<<<<<<<<
+ *     OPTIMAL        = SCIP_STATUS_OPTIMAL
+ *     INFEASIBLE     = SCIP_STATUS_INFEASIBLE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_DUALLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_DUALLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 110, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":111
+ *     PRIMALLIMIT    = SCIP_STATUS_PRIMALLIMIT
+ *     DUALLIMIT      = SCIP_STATUS_DUALLIMIT
+ *     OPTIMAL        = SCIP_STATUS_OPTIMAL             # <<<<<<<<<<<<<<
+ *     INFEASIBLE     = SCIP_STATUS_INFEASIBLE
+ *     UNBOUNDED      = SCIP_STATUS_UNBOUNDED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_OPTIMAL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_OPTIMAL, __pyx_t_2) < 0) __PYX_ERR(0, 111, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":112
+ *     DUALLIMIT      = SCIP_STATUS_DUALLIMIT
+ *     OPTIMAL        = SCIP_STATUS_OPTIMAL
+ *     INFEASIBLE     = SCIP_STATUS_INFEASIBLE             # <<<<<<<<<<<<<<
+ *     UNBOUNDED      = SCIP_STATUS_UNBOUNDED
+ *     INFORUNBD      = SCIP_STATUS_INFORUNBD
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_INFEASIBLE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_INFEASIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 112, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":113
+ *     OPTIMAL        = SCIP_STATUS_OPTIMAL
+ *     INFEASIBLE     = SCIP_STATUS_INFEASIBLE
+ *     UNBOUNDED      = SCIP_STATUS_UNBOUNDED             # <<<<<<<<<<<<<<
+ *     INFORUNBD      = SCIP_STATUS_INFORUNBD
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_UNBOUNDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_UNBOUNDED, __pyx_t_2) < 0) __PYX_ERR(0, 113, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":114
+ *     INFEASIBLE     = SCIP_STATUS_INFEASIBLE
+ *     UNBOUNDED      = SCIP_STATUS_UNBOUNDED
+ *     INFORUNBD      = SCIP_STATUS_INFORUNBD             # <<<<<<<<<<<<<<
+ * 
+ * StageNames = {}
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS_INFORUNBD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_INFORUNBD, __pyx_t_2) < 0) __PYX_ERR(0, 114, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_14PY_SCIP_STATUS_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_STATUS___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__449)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_STATUS, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_STATUS__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_14PY_SCIP_STATUS_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_STATUS___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__450)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STATUS);
+
+  /* "src/pyscipopt/scip.pxi":116
+ *     INFORUNBD      = SCIP_STATUS_INFORUNBD
+ * 
+ * StageNames = {}             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_STAGE:
+ */
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_StageNames, __pyx_t_2) < 0) __PYX_ERR(0, 116, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":119
+ * 
+ * cdef class PY_SCIP_STAGE:
+ *     INIT         = SCIP_STAGE_INIT             # <<<<<<<<<<<<<<
+ *     PROBLEM      = SCIP_STAGE_PROBLEM
+ *     TRANSFORMING = SCIP_STAGE_TRANSFORMING
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_INIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_INIT, __pyx_t_2) < 0) __PYX_ERR(0, 119, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":120
+ * cdef class PY_SCIP_STAGE:
+ *     INIT         = SCIP_STAGE_INIT
+ *     PROBLEM      = SCIP_STAGE_PROBLEM             # <<<<<<<<<<<<<<
+ *     TRANSFORMING = SCIP_STAGE_TRANSFORMING
+ *     TRANSFORMED  = SCIP_STAGE_TRANSFORMED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_PROBLEM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_PROBLEM, __pyx_t_2) < 0) __PYX_ERR(0, 120, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":121
+ *     INIT         = SCIP_STAGE_INIT
+ *     PROBLEM      = SCIP_STAGE_PROBLEM
+ *     TRANSFORMING = SCIP_STAGE_TRANSFORMING             # <<<<<<<<<<<<<<
+ *     TRANSFORMED  = SCIP_STAGE_TRANSFORMED
+ *     INITPRESOLVE = SCIP_STAGE_INITPRESOLVE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_TRANSFORMING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_TRANSFORMING, __pyx_t_2) < 0) __PYX_ERR(0, 121, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":122
+ *     PROBLEM      = SCIP_STAGE_PROBLEM
+ *     TRANSFORMING = SCIP_STAGE_TRANSFORMING
+ *     TRANSFORMED  = SCIP_STAGE_TRANSFORMED             # <<<<<<<<<<<<<<
+ *     INITPRESOLVE = SCIP_STAGE_INITPRESOLVE
+ *     PRESOLVING   = SCIP_STAGE_PRESOLVING
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_TRANSFORMED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_TRANSFORMED, __pyx_t_2) < 0) __PYX_ERR(0, 122, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":123
+ *     TRANSFORMING = SCIP_STAGE_TRANSFORMING
+ *     TRANSFORMED  = SCIP_STAGE_TRANSFORMED
+ *     INITPRESOLVE = SCIP_STAGE_INITPRESOLVE             # <<<<<<<<<<<<<<
+ *     PRESOLVING   = SCIP_STAGE_PRESOLVING
+ *     EXITPRESOLVE = SCIP_STAGE_EXITPRESOLVE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_INITPRESOLVE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_INITPRESOLVE, __pyx_t_2) < 0) __PYX_ERR(0, 123, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":124
+ *     TRANSFORMED  = SCIP_STAGE_TRANSFORMED
+ *     INITPRESOLVE = SCIP_STAGE_INITPRESOLVE
+ *     PRESOLVING   = SCIP_STAGE_PRESOLVING             # <<<<<<<<<<<<<<
+ *     EXITPRESOLVE = SCIP_STAGE_EXITPRESOLVE
+ *     PRESOLVED    = SCIP_STAGE_PRESOLVED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_PRESOLVING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_PRESOLVING, __pyx_t_2) < 0) __PYX_ERR(0, 124, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":125
+ *     INITPRESOLVE = SCIP_STAGE_INITPRESOLVE
+ *     PRESOLVING   = SCIP_STAGE_PRESOLVING
+ *     EXITPRESOLVE = SCIP_STAGE_EXITPRESOLVE             # <<<<<<<<<<<<<<
+ *     PRESOLVED    = SCIP_STAGE_PRESOLVED
+ *     INITSOLVE    = SCIP_STAGE_INITSOLVE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_EXITPRESOLVE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_EXITPRESOLVE, __pyx_t_2) < 0) __PYX_ERR(0, 125, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":126
+ *     PRESOLVING   = SCIP_STAGE_PRESOLVING
+ *     EXITPRESOLVE = SCIP_STAGE_EXITPRESOLVE
+ *     PRESOLVED    = SCIP_STAGE_PRESOLVED             # <<<<<<<<<<<<<<
+ *     INITSOLVE    = SCIP_STAGE_INITSOLVE
+ *     SOLVING      = SCIP_STAGE_SOLVING
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_PRESOLVED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_PRESOLVED, __pyx_t_2) < 0) __PYX_ERR(0, 126, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":127
+ *     EXITPRESOLVE = SCIP_STAGE_EXITPRESOLVE
+ *     PRESOLVED    = SCIP_STAGE_PRESOLVED
+ *     INITSOLVE    = SCIP_STAGE_INITSOLVE             # <<<<<<<<<<<<<<
+ *     SOLVING      = SCIP_STAGE_SOLVING
+ *     SOLVED       = SCIP_STAGE_SOLVED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_INITSOLVE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_INITSOLVE, __pyx_t_2) < 0) __PYX_ERR(0, 127, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":128
+ *     PRESOLVED    = SCIP_STAGE_PRESOLVED
+ *     INITSOLVE    = SCIP_STAGE_INITSOLVE
+ *     SOLVING      = SCIP_STAGE_SOLVING             # <<<<<<<<<<<<<<
+ *     SOLVED       = SCIP_STAGE_SOLVED
+ *     EXITSOLVE    = SCIP_STAGE_EXITSOLVE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_SOLVING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_SOLVING, __pyx_t_2) < 0) __PYX_ERR(0, 128, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":129
+ *     INITSOLVE    = SCIP_STAGE_INITSOLVE
+ *     SOLVING      = SCIP_STAGE_SOLVING
+ *     SOLVED       = SCIP_STAGE_SOLVED             # <<<<<<<<<<<<<<
+ *     EXITSOLVE    = SCIP_STAGE_EXITSOLVE
+ *     FREETRANS    = SCIP_STAGE_FREETRANS
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_SOLVED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_SOLVED, __pyx_t_2) < 0) __PYX_ERR(0, 129, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":130
+ *     SOLVING      = SCIP_STAGE_SOLVING
+ *     SOLVED       = SCIP_STAGE_SOLVED
+ *     EXITSOLVE    = SCIP_STAGE_EXITSOLVE             # <<<<<<<<<<<<<<
+ *     FREETRANS    = SCIP_STAGE_FREETRANS
+ *     FREE         = SCIP_STAGE_FREE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_EXITSOLVE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_EXITSOLVE, __pyx_t_2) < 0) __PYX_ERR(0, 130, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":131
+ *     SOLVED       = SCIP_STAGE_SOLVED
+ *     EXITSOLVE    = SCIP_STAGE_EXITSOLVE
+ *     FREETRANS    = SCIP_STAGE_FREETRANS             # <<<<<<<<<<<<<<
+ *     FREE         = SCIP_STAGE_FREE
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_FREETRANS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_FREETRANS, __pyx_t_2) < 0) __PYX_ERR(0, 131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":132
+ *     EXITSOLVE    = SCIP_STAGE_EXITSOLVE
+ *     FREETRANS    = SCIP_STAGE_FREETRANS
+ *     FREE         = SCIP_STAGE_FREE             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_NODETYPE:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE_FREE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_FREE, __pyx_t_2) < 0) __PYX_ERR(0, 132, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_13PY_SCIP_STAGE_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_STAGE___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__451)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_STAGE, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_STAGE__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_13PY_SCIP_STAGE_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_STAGE___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__452)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_STAGE);
+
+  /* "src/pyscipopt/scip.pxi":135
+ * 
+ * cdef class PY_SCIP_NODETYPE:
+ *     FOCUSNODE   = SCIP_NODETYPE_FOCUSNODE             # <<<<<<<<<<<<<<
+ *     PROBINGNODE = SCIP_NODETYPE_PROBINGNODE
+ *     SIBLING     = SCIP_NODETYPE_SIBLING
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_FOCUSNODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 135, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_FOCUSNODE, __pyx_t_2) < 0) __PYX_ERR(0, 135, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":136
+ * cdef class PY_SCIP_NODETYPE:
+ *     FOCUSNODE   = SCIP_NODETYPE_FOCUSNODE
+ *     PROBINGNODE = SCIP_NODETYPE_PROBINGNODE             # <<<<<<<<<<<<<<
+ *     SIBLING     = SCIP_NODETYPE_SIBLING
+ *     CHILD       = SCIP_NODETYPE_CHILD
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_PROBINGNODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_PROBINGNODE, __pyx_t_2) < 0) __PYX_ERR(0, 136, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":137
+ *     FOCUSNODE   = SCIP_NODETYPE_FOCUSNODE
+ *     PROBINGNODE = SCIP_NODETYPE_PROBINGNODE
+ *     SIBLING     = SCIP_NODETYPE_SIBLING             # <<<<<<<<<<<<<<
+ *     CHILD       = SCIP_NODETYPE_CHILD
+ *     LEAF        = SCIP_NODETYPE_LEAF
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_SIBLING); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_SIBLING, __pyx_t_2) < 0) __PYX_ERR(0, 137, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":138
+ *     PROBINGNODE = SCIP_NODETYPE_PROBINGNODE
+ *     SIBLING     = SCIP_NODETYPE_SIBLING
+ *     CHILD       = SCIP_NODETYPE_CHILD             # <<<<<<<<<<<<<<
+ *     LEAF        = SCIP_NODETYPE_LEAF
+ *     DEADEND     = SCIP_NODETYPE_DEADEND
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_CHILD); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_CHILD, __pyx_t_2) < 0) __PYX_ERR(0, 138, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":139
+ *     SIBLING     = SCIP_NODETYPE_SIBLING
+ *     CHILD       = SCIP_NODETYPE_CHILD
+ *     LEAF        = SCIP_NODETYPE_LEAF             # <<<<<<<<<<<<<<
+ *     DEADEND     = SCIP_NODETYPE_DEADEND
+ *     JUNCTION    = SCIP_NODETYPE_JUNCTION
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_LEAF); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_LEAF, __pyx_t_2) < 0) __PYX_ERR(0, 139, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":140
+ *     CHILD       = SCIP_NODETYPE_CHILD
+ *     LEAF        = SCIP_NODETYPE_LEAF
+ *     DEADEND     = SCIP_NODETYPE_DEADEND             # <<<<<<<<<<<<<<
+ *     JUNCTION    = SCIP_NODETYPE_JUNCTION
+ *     PSEUDOFORK  = SCIP_NODETYPE_PSEUDOFORK
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_DEADEND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 140, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_DEADEND, __pyx_t_2) < 0) __PYX_ERR(0, 140, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":141
+ *     LEAF        = SCIP_NODETYPE_LEAF
+ *     DEADEND     = SCIP_NODETYPE_DEADEND
+ *     JUNCTION    = SCIP_NODETYPE_JUNCTION             # <<<<<<<<<<<<<<
+ *     PSEUDOFORK  = SCIP_NODETYPE_PSEUDOFORK
+ *     FORK        = SCIP_NODETYPE_FORK
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_JUNCTION); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_JUNCTION, __pyx_t_2) < 0) __PYX_ERR(0, 141, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":142
+ *     DEADEND     = SCIP_NODETYPE_DEADEND
+ *     JUNCTION    = SCIP_NODETYPE_JUNCTION
+ *     PSEUDOFORK  = SCIP_NODETYPE_PSEUDOFORK             # <<<<<<<<<<<<<<
+ *     FORK        = SCIP_NODETYPE_FORK
+ *     SUBROOT     = SCIP_NODETYPE_SUBROOT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_PSEUDOFORK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_PSEUDOFORK, __pyx_t_2) < 0) __PYX_ERR(0, 142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":143
+ *     JUNCTION    = SCIP_NODETYPE_JUNCTION
+ *     PSEUDOFORK  = SCIP_NODETYPE_PSEUDOFORK
+ *     FORK        = SCIP_NODETYPE_FORK             # <<<<<<<<<<<<<<
+ *     SUBROOT     = SCIP_NODETYPE_SUBROOT
+ *     REFOCUSNODE = SCIP_NODETYPE_REFOCUSNODE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_FORK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_FORK, __pyx_t_2) < 0) __PYX_ERR(0, 143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":144
+ *     PSEUDOFORK  = SCIP_NODETYPE_PSEUDOFORK
+ *     FORK        = SCIP_NODETYPE_FORK
+ *     SUBROOT     = SCIP_NODETYPE_SUBROOT             # <<<<<<<<<<<<<<
+ *     REFOCUSNODE = SCIP_NODETYPE_REFOCUSNODE
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_SUBROOT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_SUBROOT, __pyx_t_2) < 0) __PYX_ERR(0, 144, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":145
+ *     FORK        = SCIP_NODETYPE_FORK
+ *     SUBROOT     = SCIP_NODETYPE_SUBROOT
+ *     REFOCUSNODE = SCIP_NODETYPE_REFOCUSNODE             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE_REFOCUSNODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_REFOCUSNODE, __pyx_t_2) < 0) __PYX_ERR(0, 145, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_16PY_SCIP_NODETYPE_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_NODETYPE___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__453)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_NODETYPE, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_NODETYPE__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_16PY_SCIP_NODETYPE_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_NODETYPE___setstate_cyth, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__454)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_NODETYPE);
+
+  /* "src/pyscipopt/scip.pxi":149
+ * 
+ * cdef class PY_SCIP_PROPTIMING:
+ *     BEFORELP     = SCIP_PROPTIMING_BEFORELP             # <<<<<<<<<<<<<<
+ *     DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP
+ *     AFTERLPLOOP  = SCIP_PROPTIMING_AFTERLPLOOP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PROPTIMING(SCIP_PROPTIMING_BEFORELP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING, __pyx_n_s_BEFORELP, __pyx_t_2) < 0) __PYX_ERR(0, 149, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING);
+
+  /* "src/pyscipopt/scip.pxi":150
+ * cdef class PY_SCIP_PROPTIMING:
+ *     BEFORELP     = SCIP_PROPTIMING_BEFORELP
+ *     DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP             # <<<<<<<<<<<<<<
+ *     AFTERLPLOOP  = SCIP_PROPTIMING_AFTERLPLOOP
+ *     AFTERLPNODE  = SCIP_PROPTIMING_AFTERLPNODE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PROPTIMING(SCIP_PROPTIMING_DURINGLPLOOP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING, __pyx_n_s_DURINGLPLOOP, __pyx_t_2) < 0) __PYX_ERR(0, 150, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING);
+
+  /* "src/pyscipopt/scip.pxi":151
+ *     BEFORELP     = SCIP_PROPTIMING_BEFORELP
+ *     DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP
+ *     AFTERLPLOOP  = SCIP_PROPTIMING_AFTERLPLOOP             # <<<<<<<<<<<<<<
+ *     AFTERLPNODE  = SCIP_PROPTIMING_AFTERLPNODE
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PROPTIMING(SCIP_PROPTIMING_AFTERLPLOOP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING, __pyx_n_s_AFTERLPLOOP, __pyx_t_2) < 0) __PYX_ERR(0, 151, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING);
+
+  /* "src/pyscipopt/scip.pxi":152
+ *     DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP
+ *     AFTERLPLOOP  = SCIP_PROPTIMING_AFTERLPLOOP
+ *     AFTERLPNODE  = SCIP_PROPTIMING_AFTERLPNODE             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_PRESOLTIMING:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PROPTIMING(SCIP_PROPTIMING_AFTERLPNODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING, __pyx_n_s_AFTERLPNODE, __pyx_t_2) < 0) __PYX_ERR(0, 152, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_PROPTIMING___reduce_cyth, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__455)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_PROPTIMING, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_18PY_SCIP_PROPTIMING_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_PROPTIMING___setstate_cy, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__456)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING);
+
+  /* "src/pyscipopt/scip.pxi":155
+ * 
+ * cdef class PY_SCIP_PRESOLTIMING:
+ *     NONE       = SCIP_PRESOLTIMING_NONE             # <<<<<<<<<<<<<<
+ *     FAST       = SCIP_PRESOLTIMING_FAST
+ *     MEDIUM     = SCIP_PRESOLTIMING_MEDIUM
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING_NONE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, __pyx_n_s_NONE, __pyx_t_2) < 0) __PYX_ERR(0, 155, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING);
+
+  /* "src/pyscipopt/scip.pxi":156
+ * cdef class PY_SCIP_PRESOLTIMING:
+ *     NONE       = SCIP_PRESOLTIMING_NONE
+ *     FAST       = SCIP_PRESOLTIMING_FAST             # <<<<<<<<<<<<<<
+ *     MEDIUM     = SCIP_PRESOLTIMING_MEDIUM
+ *     EXHAUSTIVE = SCIP_PRESOLTIMING_EXHAUSTIVE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING_FAST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, __pyx_n_s_FAST, __pyx_t_2) < 0) __PYX_ERR(0, 156, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING);
+
+  /* "src/pyscipopt/scip.pxi":157
+ *     NONE       = SCIP_PRESOLTIMING_NONE
+ *     FAST       = SCIP_PRESOLTIMING_FAST
+ *     MEDIUM     = SCIP_PRESOLTIMING_MEDIUM             # <<<<<<<<<<<<<<
+ *     EXHAUSTIVE = SCIP_PRESOLTIMING_EXHAUSTIVE
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING_MEDIUM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, __pyx_n_s_MEDIUM, __pyx_t_2) < 0) __PYX_ERR(0, 157, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING);
+
+  /* "src/pyscipopt/scip.pxi":158
+ *     FAST       = SCIP_PRESOLTIMING_FAST
+ *     MEDIUM     = SCIP_PRESOLTIMING_MEDIUM
+ *     EXHAUSTIVE = SCIP_PRESOLTIMING_EXHAUSTIVE             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_HEURTIMING:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING_EXHAUSTIVE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, __pyx_n_s_EXHAUSTIVE, __pyx_t_2) < 0) __PYX_ERR(0, 158, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_PRESOLTIMING___reduce_cy, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__457)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_PRESOLTIMING, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_PRESOLTIMING__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_20PY_SCIP_PRESOLTIMING_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_PRESOLTIMING___setstate, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__458)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING);
+
+  /* "src/pyscipopt/scip.pxi":161
+ * 
+ * cdef class PY_SCIP_HEURTIMING:
+ *     BEFORENODE        = SCIP_HEURTIMING_BEFORENODE             # <<<<<<<<<<<<<<
+ *     DURINGLPLOOP      = SCIP_HEURTIMING_DURINGLPLOOP
+ *     AFTERLPLOOP       = SCIP_HEURTIMING_AFTERLPLOOP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_BEFORENODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_BEFORENODE, __pyx_t_2) < 0) __PYX_ERR(0, 161, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":162
+ * cdef class PY_SCIP_HEURTIMING:
+ *     BEFORENODE        = SCIP_HEURTIMING_BEFORENODE
+ *     DURINGLPLOOP      = SCIP_HEURTIMING_DURINGLPLOOP             # <<<<<<<<<<<<<<
+ *     AFTERLPLOOP       = SCIP_HEURTIMING_AFTERLPLOOP
+ *     AFTERLPNODE       = SCIP_HEURTIMING_AFTERLPNODE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_DURINGLPLOOP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_DURINGLPLOOP, __pyx_t_2) < 0) __PYX_ERR(0, 162, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":163
+ *     BEFORENODE        = SCIP_HEURTIMING_BEFORENODE
+ *     DURINGLPLOOP      = SCIP_HEURTIMING_DURINGLPLOOP
+ *     AFTERLPLOOP       = SCIP_HEURTIMING_AFTERLPLOOP             # <<<<<<<<<<<<<<
+ *     AFTERLPNODE       = SCIP_HEURTIMING_AFTERLPNODE
+ *     AFTERPSEUDONODE   = SCIP_HEURTIMING_AFTERPSEUDONODE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_AFTERLPLOOP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_AFTERLPLOOP, __pyx_t_2) < 0) __PYX_ERR(0, 163, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":164
+ *     DURINGLPLOOP      = SCIP_HEURTIMING_DURINGLPLOOP
+ *     AFTERLPLOOP       = SCIP_HEURTIMING_AFTERLPLOOP
+ *     AFTERLPNODE       = SCIP_HEURTIMING_AFTERLPNODE             # <<<<<<<<<<<<<<
+ *     AFTERPSEUDONODE   = SCIP_HEURTIMING_AFTERPSEUDONODE
+ *     AFTERLPPLUNGE     = SCIP_HEURTIMING_AFTERLPPLUNGE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_AFTERLPNODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_AFTERLPNODE, __pyx_t_2) < 0) __PYX_ERR(0, 164, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":165
+ *     AFTERLPLOOP       = SCIP_HEURTIMING_AFTERLPLOOP
+ *     AFTERLPNODE       = SCIP_HEURTIMING_AFTERLPNODE
+ *     AFTERPSEUDONODE   = SCIP_HEURTIMING_AFTERPSEUDONODE             # <<<<<<<<<<<<<<
+ *     AFTERLPPLUNGE     = SCIP_HEURTIMING_AFTERLPPLUNGE
+ *     AFTERPSEUDOPLUNGE = SCIP_HEURTIMING_AFTERPSEUDOPLUNGE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_AFTERPSEUDONODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_AFTERPSEUDONODE, __pyx_t_2) < 0) __PYX_ERR(0, 165, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":166
+ *     AFTERLPNODE       = SCIP_HEURTIMING_AFTERLPNODE
+ *     AFTERPSEUDONODE   = SCIP_HEURTIMING_AFTERPSEUDONODE
+ *     AFTERLPPLUNGE     = SCIP_HEURTIMING_AFTERLPPLUNGE             # <<<<<<<<<<<<<<
+ *     AFTERPSEUDOPLUNGE = SCIP_HEURTIMING_AFTERPSEUDOPLUNGE
+ *     DURINGPRICINGLOOP = SCIP_HEURTIMING_DURINGPRICINGLOOP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_AFTERLPPLUNGE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_AFTERLPPLUNGE, __pyx_t_2) < 0) __PYX_ERR(0, 166, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":167
+ *     AFTERPSEUDONODE   = SCIP_HEURTIMING_AFTERPSEUDONODE
+ *     AFTERLPPLUNGE     = SCIP_HEURTIMING_AFTERLPPLUNGE
+ *     AFTERPSEUDOPLUNGE = SCIP_HEURTIMING_AFTERPSEUDOPLUNGE             # <<<<<<<<<<<<<<
+ *     DURINGPRICINGLOOP = SCIP_HEURTIMING_DURINGPRICINGLOOP
+ *     BEFOREPRESOL      = SCIP_HEURTIMING_BEFOREPRESOL
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_AFTERPSEUDOPLUNGE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 167, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_AFTERPSEUDOPLUNGE, __pyx_t_2) < 0) __PYX_ERR(0, 167, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":168
+ *     AFTERLPPLUNGE     = SCIP_HEURTIMING_AFTERLPPLUNGE
+ *     AFTERPSEUDOPLUNGE = SCIP_HEURTIMING_AFTERPSEUDOPLUNGE
+ *     DURINGPRICINGLOOP = SCIP_HEURTIMING_DURINGPRICINGLOOP             # <<<<<<<<<<<<<<
+ *     BEFOREPRESOL      = SCIP_HEURTIMING_BEFOREPRESOL
+ *     DURINGPRESOLLOOP  = SCIP_HEURTIMING_DURINGPRESOLLOOP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_DURINGPRICINGLOOP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_DURINGPRICINGLOOP, __pyx_t_2) < 0) __PYX_ERR(0, 168, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":169
+ *     AFTERPSEUDOPLUNGE = SCIP_HEURTIMING_AFTERPSEUDOPLUNGE
+ *     DURINGPRICINGLOOP = SCIP_HEURTIMING_DURINGPRICINGLOOP
+ *     BEFOREPRESOL      = SCIP_HEURTIMING_BEFOREPRESOL             # <<<<<<<<<<<<<<
+ *     DURINGPRESOLLOOP  = SCIP_HEURTIMING_DURINGPRESOLLOOP
+ *     AFTERPROPLOOP     = SCIP_HEURTIMING_AFTERPROPLOOP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_BEFOREPRESOL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_BEFOREPRESOL, __pyx_t_2) < 0) __PYX_ERR(0, 169, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":170
+ *     DURINGPRICINGLOOP = SCIP_HEURTIMING_DURINGPRICINGLOOP
+ *     BEFOREPRESOL      = SCIP_HEURTIMING_BEFOREPRESOL
+ *     DURINGPRESOLLOOP  = SCIP_HEURTIMING_DURINGPRESOLLOOP             # <<<<<<<<<<<<<<
+ *     AFTERPROPLOOP     = SCIP_HEURTIMING_AFTERPROPLOOP
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_DURINGPRESOLLOOP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_DURINGPRESOLLOOP, __pyx_t_2) < 0) __PYX_ERR(0, 170, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":171
+ *     BEFOREPRESOL      = SCIP_HEURTIMING_BEFOREPRESOL
+ *     DURINGPRESOLLOOP  = SCIP_HEURTIMING_DURINGPRESOLLOOP
+ *     AFTERPROPLOOP     = SCIP_HEURTIMING_AFTERPROPLOOP             # <<<<<<<<<<<<<<
+ * 
+ * EventNames = {}
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_AFTERPROPLOOP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_AFTERPROPLOOP, __pyx_t_2) < 0) __PYX_ERR(0, 171, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_HEURTIMING___reduce_cyth, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__459)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_HEURTIMING, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_18PY_SCIP_HEURTIMING_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_HEURTIMING___setstate_cy, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__460)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_HEURTIMING);
+
+  /* "src/pyscipopt/scip.pxi":173
+ *     AFTERPROPLOOP     = SCIP_HEURTIMING_AFTERPROPLOOP
+ * 
+ * EventNames = {}             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_EVENTTYPE:
+ */
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_EventNames, __pyx_t_2) < 0) __PYX_ERR(0, 173, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":176
+ * 
+ * cdef class PY_SCIP_EVENTTYPE:
+ *     DISABLED        = SCIP_EVENTTYPE_DISABLED             # <<<<<<<<<<<<<<
+ *     VARADDED        = SCIP_EVENTTYPE_VARADDED
+ *     VARDELETED      = SCIP_EVENTTYPE_VARDELETED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_DISABLED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_DISABLED, __pyx_t_2) < 0) __PYX_ERR(0, 176, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":177
+ * cdef class PY_SCIP_EVENTTYPE:
+ *     DISABLED        = SCIP_EVENTTYPE_DISABLED
+ *     VARADDED        = SCIP_EVENTTYPE_VARADDED             # <<<<<<<<<<<<<<
+ *     VARDELETED      = SCIP_EVENTTYPE_VARDELETED
+ *     VARFIXED        = SCIP_EVENTTYPE_VARFIXED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_VARADDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_VARADDED, __pyx_t_2) < 0) __PYX_ERR(0, 177, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":178
+ *     DISABLED        = SCIP_EVENTTYPE_DISABLED
+ *     VARADDED        = SCIP_EVENTTYPE_VARADDED
+ *     VARDELETED      = SCIP_EVENTTYPE_VARDELETED             # <<<<<<<<<<<<<<
+ *     VARFIXED        = SCIP_EVENTTYPE_VARFIXED
+ *     VARUNLOCKED     = SCIP_EVENTTYPE_VARUNLOCKED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_VARDELETED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_VARDELETED, __pyx_t_2) < 0) __PYX_ERR(0, 178, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":179
+ *     VARADDED        = SCIP_EVENTTYPE_VARADDED
+ *     VARDELETED      = SCIP_EVENTTYPE_VARDELETED
+ *     VARFIXED        = SCIP_EVENTTYPE_VARFIXED             # <<<<<<<<<<<<<<
+ *     VARUNLOCKED     = SCIP_EVENTTYPE_VARUNLOCKED
+ *     OBJCHANGED      = SCIP_EVENTTYPE_OBJCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_VARFIXED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 179, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_VARFIXED, __pyx_t_2) < 0) __PYX_ERR(0, 179, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":180
+ *     VARDELETED      = SCIP_EVENTTYPE_VARDELETED
+ *     VARFIXED        = SCIP_EVENTTYPE_VARFIXED
+ *     VARUNLOCKED     = SCIP_EVENTTYPE_VARUNLOCKED             # <<<<<<<<<<<<<<
+ *     OBJCHANGED      = SCIP_EVENTTYPE_OBJCHANGED
+ *     GLBCHANGED      = SCIP_EVENTTYPE_GLBCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_VARUNLOCKED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 180, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_VARUNLOCKED, __pyx_t_2) < 0) __PYX_ERR(0, 180, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":181
+ *     VARFIXED        = SCIP_EVENTTYPE_VARFIXED
+ *     VARUNLOCKED     = SCIP_EVENTTYPE_VARUNLOCKED
+ *     OBJCHANGED      = SCIP_EVENTTYPE_OBJCHANGED             # <<<<<<<<<<<<<<
+ *     GLBCHANGED      = SCIP_EVENTTYPE_GLBCHANGED
+ *     GUBCHANGED      = SCIP_EVENTTYPE_GUBCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_OBJCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 181, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_OBJCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 181, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":182
+ *     VARUNLOCKED     = SCIP_EVENTTYPE_VARUNLOCKED
+ *     OBJCHANGED      = SCIP_EVENTTYPE_OBJCHANGED
+ *     GLBCHANGED      = SCIP_EVENTTYPE_GLBCHANGED             # <<<<<<<<<<<<<<
+ *     GUBCHANGED      = SCIP_EVENTTYPE_GUBCHANGED
+ *     LBTIGHTENED     = SCIP_EVENTTYPE_LBTIGHTENED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_GLBCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_GLBCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 182, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":183
+ *     OBJCHANGED      = SCIP_EVENTTYPE_OBJCHANGED
+ *     GLBCHANGED      = SCIP_EVENTTYPE_GLBCHANGED
+ *     GUBCHANGED      = SCIP_EVENTTYPE_GUBCHANGED             # <<<<<<<<<<<<<<
+ *     LBTIGHTENED     = SCIP_EVENTTYPE_LBTIGHTENED
+ *     LBRELAXED       = SCIP_EVENTTYPE_LBRELAXED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_GUBCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_GUBCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 183, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":184
+ *     GLBCHANGED      = SCIP_EVENTTYPE_GLBCHANGED
+ *     GUBCHANGED      = SCIP_EVENTTYPE_GUBCHANGED
+ *     LBTIGHTENED     = SCIP_EVENTTYPE_LBTIGHTENED             # <<<<<<<<<<<<<<
+ *     LBRELAXED       = SCIP_EVENTTYPE_LBRELAXED
+ *     UBTIGHTENED     = SCIP_EVENTTYPE_UBTIGHTENED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_LBTIGHTENED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 184, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_LBTIGHTENED, __pyx_t_2) < 0) __PYX_ERR(0, 184, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":185
+ *     GUBCHANGED      = SCIP_EVENTTYPE_GUBCHANGED
+ *     LBTIGHTENED     = SCIP_EVENTTYPE_LBTIGHTENED
+ *     LBRELAXED       = SCIP_EVENTTYPE_LBRELAXED             # <<<<<<<<<<<<<<
+ *     UBTIGHTENED     = SCIP_EVENTTYPE_UBTIGHTENED
+ *     UBRELAXED       = SCIP_EVENTTYPE_UBRELAXED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_LBRELAXED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 185, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_LBRELAXED, __pyx_t_2) < 0) __PYX_ERR(0, 185, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":186
+ *     LBTIGHTENED     = SCIP_EVENTTYPE_LBTIGHTENED
+ *     LBRELAXED       = SCIP_EVENTTYPE_LBRELAXED
+ *     UBTIGHTENED     = SCIP_EVENTTYPE_UBTIGHTENED             # <<<<<<<<<<<<<<
+ *     UBRELAXED       = SCIP_EVENTTYPE_UBRELAXED
+ *     GHOLEADDED      = SCIP_EVENTTYPE_GHOLEADDED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_UBTIGHTENED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_UBTIGHTENED, __pyx_t_2) < 0) __PYX_ERR(0, 186, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":187
+ *     LBRELAXED       = SCIP_EVENTTYPE_LBRELAXED
+ *     UBTIGHTENED     = SCIP_EVENTTYPE_UBTIGHTENED
+ *     UBRELAXED       = SCIP_EVENTTYPE_UBRELAXED             # <<<<<<<<<<<<<<
+ *     GHOLEADDED      = SCIP_EVENTTYPE_GHOLEADDED
+ *     GHOLEREMOVED    = SCIP_EVENTTYPE_GHOLEREMOVED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_UBRELAXED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_UBRELAXED, __pyx_t_2) < 0) __PYX_ERR(0, 187, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":188
+ *     UBTIGHTENED     = SCIP_EVENTTYPE_UBTIGHTENED
+ *     UBRELAXED       = SCIP_EVENTTYPE_UBRELAXED
+ *     GHOLEADDED      = SCIP_EVENTTYPE_GHOLEADDED             # <<<<<<<<<<<<<<
+ *     GHOLEREMOVED    = SCIP_EVENTTYPE_GHOLEREMOVED
+ *     LHOLEADDED      = SCIP_EVENTTYPE_LHOLEADDED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_GHOLEADDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_GHOLEADDED, __pyx_t_2) < 0) __PYX_ERR(0, 188, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":189
+ *     UBRELAXED       = SCIP_EVENTTYPE_UBRELAXED
+ *     GHOLEADDED      = SCIP_EVENTTYPE_GHOLEADDED
+ *     GHOLEREMOVED    = SCIP_EVENTTYPE_GHOLEREMOVED             # <<<<<<<<<<<<<<
+ *     LHOLEADDED      = SCIP_EVENTTYPE_LHOLEADDED
+ *     LHOLEREMOVED    = SCIP_EVENTTYPE_LHOLEREMOVED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_GHOLEREMOVED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_GHOLEREMOVED, __pyx_t_2) < 0) __PYX_ERR(0, 189, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":190
+ *     GHOLEADDED      = SCIP_EVENTTYPE_GHOLEADDED
+ *     GHOLEREMOVED    = SCIP_EVENTTYPE_GHOLEREMOVED
+ *     LHOLEADDED      = SCIP_EVENTTYPE_LHOLEADDED             # <<<<<<<<<<<<<<
+ *     LHOLEREMOVED    = SCIP_EVENTTYPE_LHOLEREMOVED
+ *     IMPLADDED       = SCIP_EVENTTYPE_IMPLADDED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_LHOLEADDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_LHOLEADDED, __pyx_t_2) < 0) __PYX_ERR(0, 190, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":191
+ *     GHOLEREMOVED    = SCIP_EVENTTYPE_GHOLEREMOVED
+ *     LHOLEADDED      = SCIP_EVENTTYPE_LHOLEADDED
+ *     LHOLEREMOVED    = SCIP_EVENTTYPE_LHOLEREMOVED             # <<<<<<<<<<<<<<
+ *     IMPLADDED       = SCIP_EVENTTYPE_IMPLADDED
+ *     PRESOLVEROUND   = SCIP_EVENTTYPE_PRESOLVEROUND
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_LHOLEREMOVED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_LHOLEREMOVED, __pyx_t_2) < 0) __PYX_ERR(0, 191, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":192
+ *     LHOLEADDED      = SCIP_EVENTTYPE_LHOLEADDED
+ *     LHOLEREMOVED    = SCIP_EVENTTYPE_LHOLEREMOVED
+ *     IMPLADDED       = SCIP_EVENTTYPE_IMPLADDED             # <<<<<<<<<<<<<<
+ *     PRESOLVEROUND   = SCIP_EVENTTYPE_PRESOLVEROUND
+ *     NODEFOCUSED     = SCIP_EVENTTYPE_NODEFOCUSED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_IMPLADDED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_IMPLADDED, __pyx_t_2) < 0) __PYX_ERR(0, 192, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":193
+ *     LHOLEREMOVED    = SCIP_EVENTTYPE_LHOLEREMOVED
+ *     IMPLADDED       = SCIP_EVENTTYPE_IMPLADDED
+ *     PRESOLVEROUND   = SCIP_EVENTTYPE_PRESOLVEROUND             # <<<<<<<<<<<<<<
+ *     NODEFOCUSED     = SCIP_EVENTTYPE_NODEFOCUSED
+ *     NODEFEASIBLE    = SCIP_EVENTTYPE_NODEFEASIBLE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_PRESOLVEROUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_PRESOLVEROUND, __pyx_t_2) < 0) __PYX_ERR(0, 193, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":194
+ *     IMPLADDED       = SCIP_EVENTTYPE_IMPLADDED
+ *     PRESOLVEROUND   = SCIP_EVENTTYPE_PRESOLVEROUND
+ *     NODEFOCUSED     = SCIP_EVENTTYPE_NODEFOCUSED             # <<<<<<<<<<<<<<
+ *     NODEFEASIBLE    = SCIP_EVENTTYPE_NODEFEASIBLE
+ *     NODEINFEASIBLE  = SCIP_EVENTTYPE_NODEINFEASIBLE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_NODEFOCUSED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_NODEFOCUSED, __pyx_t_2) < 0) __PYX_ERR(0, 194, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":195
+ *     PRESOLVEROUND   = SCIP_EVENTTYPE_PRESOLVEROUND
+ *     NODEFOCUSED     = SCIP_EVENTTYPE_NODEFOCUSED
+ *     NODEFEASIBLE    = SCIP_EVENTTYPE_NODEFEASIBLE             # <<<<<<<<<<<<<<
+ *     NODEINFEASIBLE  = SCIP_EVENTTYPE_NODEINFEASIBLE
+ *     NODEBRANCHED    = SCIP_EVENTTYPE_NODEBRANCHED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_NODEFEASIBLE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 195, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_NODEFEASIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 195, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":196
+ *     NODEFOCUSED     = SCIP_EVENTTYPE_NODEFOCUSED
+ *     NODEFEASIBLE    = SCIP_EVENTTYPE_NODEFEASIBLE
+ *     NODEINFEASIBLE  = SCIP_EVENTTYPE_NODEINFEASIBLE             # <<<<<<<<<<<<<<
+ *     NODEBRANCHED    = SCIP_EVENTTYPE_NODEBRANCHED
+ *     NODEDELETE      = SCIP_EVENTTYPE_NODEDELETE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_NODEINFEASIBLE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_NODEINFEASIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 196, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":197
+ *     NODEFEASIBLE    = SCIP_EVENTTYPE_NODEFEASIBLE
+ *     NODEINFEASIBLE  = SCIP_EVENTTYPE_NODEINFEASIBLE
+ *     NODEBRANCHED    = SCIP_EVENTTYPE_NODEBRANCHED             # <<<<<<<<<<<<<<
+ *     NODEDELETE      = SCIP_EVENTTYPE_NODEDELETE
+ *     FIRSTLPSOLVED   = SCIP_EVENTTYPE_FIRSTLPSOLVED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_NODEBRANCHED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_NODEBRANCHED, __pyx_t_2) < 0) __PYX_ERR(0, 197, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":198
+ *     NODEINFEASIBLE  = SCIP_EVENTTYPE_NODEINFEASIBLE
+ *     NODEBRANCHED    = SCIP_EVENTTYPE_NODEBRANCHED
+ *     NODEDELETE      = SCIP_EVENTTYPE_NODEDELETE             # <<<<<<<<<<<<<<
+ *     FIRSTLPSOLVED   = SCIP_EVENTTYPE_FIRSTLPSOLVED
+ *     LPSOLVED        = SCIP_EVENTTYPE_LPSOLVED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_NODEDELETE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_NODEDELETE, __pyx_t_2) < 0) __PYX_ERR(0, 198, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":199
+ *     NODEBRANCHED    = SCIP_EVENTTYPE_NODEBRANCHED
+ *     NODEDELETE      = SCIP_EVENTTYPE_NODEDELETE
+ *     FIRSTLPSOLVED   = SCIP_EVENTTYPE_FIRSTLPSOLVED             # <<<<<<<<<<<<<<
+ *     LPSOLVED        = SCIP_EVENTTYPE_LPSOLVED
+ *     LPEVENT         = SCIP_EVENTTYPE_LPEVENT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_FIRSTLPSOLVED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_FIRSTLPSOLVED, __pyx_t_2) < 0) __PYX_ERR(0, 199, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":200
+ *     NODEDELETE      = SCIP_EVENTTYPE_NODEDELETE
+ *     FIRSTLPSOLVED   = SCIP_EVENTTYPE_FIRSTLPSOLVED
+ *     LPSOLVED        = SCIP_EVENTTYPE_LPSOLVED             # <<<<<<<<<<<<<<
+ *     LPEVENT         = SCIP_EVENTTYPE_LPEVENT
+ *     POORSOLFOUND    = SCIP_EVENTTYPE_POORSOLFOUND
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_LPSOLVED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_LPSOLVED, __pyx_t_2) < 0) __PYX_ERR(0, 200, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":201
+ *     FIRSTLPSOLVED   = SCIP_EVENTTYPE_FIRSTLPSOLVED
+ *     LPSOLVED        = SCIP_EVENTTYPE_LPSOLVED
+ *     LPEVENT         = SCIP_EVENTTYPE_LPEVENT             # <<<<<<<<<<<<<<
+ *     POORSOLFOUND    = SCIP_EVENTTYPE_POORSOLFOUND
+ *     BESTSOLFOUND    = SCIP_EVENTTYPE_BESTSOLFOUND
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_LPEVENT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_LPEVENT, __pyx_t_2) < 0) __PYX_ERR(0, 201, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":202
+ *     LPSOLVED        = SCIP_EVENTTYPE_LPSOLVED
+ *     LPEVENT         = SCIP_EVENTTYPE_LPEVENT
+ *     POORSOLFOUND    = SCIP_EVENTTYPE_POORSOLFOUND             # <<<<<<<<<<<<<<
+ *     BESTSOLFOUND    = SCIP_EVENTTYPE_BESTSOLFOUND
+ *     ROWADDEDSEPA    = SCIP_EVENTTYPE_ROWADDEDSEPA
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_POORSOLFOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_POORSOLFOUND, __pyx_t_2) < 0) __PYX_ERR(0, 202, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":203
+ *     LPEVENT         = SCIP_EVENTTYPE_LPEVENT
+ *     POORSOLFOUND    = SCIP_EVENTTYPE_POORSOLFOUND
+ *     BESTSOLFOUND    = SCIP_EVENTTYPE_BESTSOLFOUND             # <<<<<<<<<<<<<<
+ *     ROWADDEDSEPA    = SCIP_EVENTTYPE_ROWADDEDSEPA
+ *     ROWDELETEDSEPA  = SCIP_EVENTTYPE_ROWDELETEDSEPA
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_BESTSOLFOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_BESTSOLFOUND, __pyx_t_2) < 0) __PYX_ERR(0, 203, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":204
+ *     POORSOLFOUND    = SCIP_EVENTTYPE_POORSOLFOUND
+ *     BESTSOLFOUND    = SCIP_EVENTTYPE_BESTSOLFOUND
+ *     ROWADDEDSEPA    = SCIP_EVENTTYPE_ROWADDEDSEPA             # <<<<<<<<<<<<<<
+ *     ROWDELETEDSEPA  = SCIP_EVENTTYPE_ROWDELETEDSEPA
+ *     ROWADDEDLP      = SCIP_EVENTTYPE_ROWADDEDLP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWADDEDSEPA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWADDEDSEPA, __pyx_t_2) < 0) __PYX_ERR(0, 204, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":205
+ *     BESTSOLFOUND    = SCIP_EVENTTYPE_BESTSOLFOUND
+ *     ROWADDEDSEPA    = SCIP_EVENTTYPE_ROWADDEDSEPA
+ *     ROWDELETEDSEPA  = SCIP_EVENTTYPE_ROWDELETEDSEPA             # <<<<<<<<<<<<<<
+ *     ROWADDEDLP      = SCIP_EVENTTYPE_ROWADDEDLP
+ *     ROWDELETEDLP    = SCIP_EVENTTYPE_ROWDELETEDLP
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWDELETEDSEPA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWDELETEDSEPA, __pyx_t_2) < 0) __PYX_ERR(0, 205, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":206
+ *     ROWADDEDSEPA    = SCIP_EVENTTYPE_ROWADDEDSEPA
+ *     ROWDELETEDSEPA  = SCIP_EVENTTYPE_ROWDELETEDSEPA
+ *     ROWADDEDLP      = SCIP_EVENTTYPE_ROWADDEDLP             # <<<<<<<<<<<<<<
+ *     ROWDELETEDLP    = SCIP_EVENTTYPE_ROWDELETEDLP
+ *     ROWCOEFCHANGED  = SCIP_EVENTTYPE_ROWCOEFCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWADDEDLP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWADDEDLP, __pyx_t_2) < 0) __PYX_ERR(0, 206, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":207
+ *     ROWDELETEDSEPA  = SCIP_EVENTTYPE_ROWDELETEDSEPA
+ *     ROWADDEDLP      = SCIP_EVENTTYPE_ROWADDEDLP
+ *     ROWDELETEDLP    = SCIP_EVENTTYPE_ROWDELETEDLP             # <<<<<<<<<<<<<<
+ *     ROWCOEFCHANGED  = SCIP_EVENTTYPE_ROWCOEFCHANGED
+ *     ROWCONSTCHANGED = SCIP_EVENTTYPE_ROWCONSTCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWDELETEDLP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWDELETEDLP, __pyx_t_2) < 0) __PYX_ERR(0, 207, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":208
+ *     ROWADDEDLP      = SCIP_EVENTTYPE_ROWADDEDLP
+ *     ROWDELETEDLP    = SCIP_EVENTTYPE_ROWDELETEDLP
+ *     ROWCOEFCHANGED  = SCIP_EVENTTYPE_ROWCOEFCHANGED             # <<<<<<<<<<<<<<
+ *     ROWCONSTCHANGED = SCIP_EVENTTYPE_ROWCONSTCHANGED
+ *     ROWSIDECHANGED  = SCIP_EVENTTYPE_ROWSIDECHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWCOEFCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWCOEFCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 208, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":209
+ *     ROWDELETEDLP    = SCIP_EVENTTYPE_ROWDELETEDLP
+ *     ROWCOEFCHANGED  = SCIP_EVENTTYPE_ROWCOEFCHANGED
+ *     ROWCONSTCHANGED = SCIP_EVENTTYPE_ROWCONSTCHANGED             # <<<<<<<<<<<<<<
+ *     ROWSIDECHANGED  = SCIP_EVENTTYPE_ROWSIDECHANGED
+ *     SYNC            = SCIP_EVENTTYPE_SYNC
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWCONSTCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWCONSTCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 209, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":210
+ *     ROWCOEFCHANGED  = SCIP_EVENTTYPE_ROWCOEFCHANGED
+ *     ROWCONSTCHANGED = SCIP_EVENTTYPE_ROWCONSTCHANGED
+ *     ROWSIDECHANGED  = SCIP_EVENTTYPE_ROWSIDECHANGED             # <<<<<<<<<<<<<<
+ *     SYNC            = SCIP_EVENTTYPE_SYNC
+ *     GBDCHANGED      = SCIP_EVENTTYPE_GBDCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWSIDECHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWSIDECHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 210, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":211
+ *     ROWCONSTCHANGED = SCIP_EVENTTYPE_ROWCONSTCHANGED
+ *     ROWSIDECHANGED  = SCIP_EVENTTYPE_ROWSIDECHANGED
+ *     SYNC            = SCIP_EVENTTYPE_SYNC             # <<<<<<<<<<<<<<
+ *     GBDCHANGED      = SCIP_EVENTTYPE_GBDCHANGED
+ *     LBCHANGED       = SCIP_EVENTTYPE_LBCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_SYNC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_SYNC, __pyx_t_2) < 0) __PYX_ERR(0, 211, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":212
+ *     ROWSIDECHANGED  = SCIP_EVENTTYPE_ROWSIDECHANGED
+ *     SYNC            = SCIP_EVENTTYPE_SYNC
+ *     GBDCHANGED      = SCIP_EVENTTYPE_GBDCHANGED             # <<<<<<<<<<<<<<
+ *     LBCHANGED       = SCIP_EVENTTYPE_LBCHANGED
+ *     UBCHANGED       = SCIP_EVENTTYPE_UBCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_GBDCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_GBDCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 212, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":213
+ *     SYNC            = SCIP_EVENTTYPE_SYNC
+ *     GBDCHANGED      = SCIP_EVENTTYPE_GBDCHANGED
+ *     LBCHANGED       = SCIP_EVENTTYPE_LBCHANGED             # <<<<<<<<<<<<<<
+ *     UBCHANGED       = SCIP_EVENTTYPE_UBCHANGED
+ *     BOUNDTIGHTENED  = SCIP_EVENTTYPE_BOUNDTIGHTENED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_LBCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_LBCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 213, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":214
+ *     GBDCHANGED      = SCIP_EVENTTYPE_GBDCHANGED
+ *     LBCHANGED       = SCIP_EVENTTYPE_LBCHANGED
+ *     UBCHANGED       = SCIP_EVENTTYPE_UBCHANGED             # <<<<<<<<<<<<<<
+ *     BOUNDTIGHTENED  = SCIP_EVENTTYPE_BOUNDTIGHTENED
+ *     BOUNDRELAXED    = SCIP_EVENTTYPE_BOUNDRELAXED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_UBCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_UBCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 214, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":215
+ *     LBCHANGED       = SCIP_EVENTTYPE_LBCHANGED
+ *     UBCHANGED       = SCIP_EVENTTYPE_UBCHANGED
+ *     BOUNDTIGHTENED  = SCIP_EVENTTYPE_BOUNDTIGHTENED             # <<<<<<<<<<<<<<
+ *     BOUNDRELAXED    = SCIP_EVENTTYPE_BOUNDRELAXED
+ *     BOUNDCHANGED    = SCIP_EVENTTYPE_BOUNDCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_BOUNDTIGHTENED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_BOUNDTIGHTENED, __pyx_t_2) < 0) __PYX_ERR(0, 215, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":216
+ *     UBCHANGED       = SCIP_EVENTTYPE_UBCHANGED
+ *     BOUNDTIGHTENED  = SCIP_EVENTTYPE_BOUNDTIGHTENED
+ *     BOUNDRELAXED    = SCIP_EVENTTYPE_BOUNDRELAXED             # <<<<<<<<<<<<<<
+ *     BOUNDCHANGED    = SCIP_EVENTTYPE_BOUNDCHANGED
+ *     GHOLECHANGED    = SCIP_EVENTTYPE_GHOLECHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_BOUNDRELAXED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_BOUNDRELAXED, __pyx_t_2) < 0) __PYX_ERR(0, 216, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":217
+ *     BOUNDTIGHTENED  = SCIP_EVENTTYPE_BOUNDTIGHTENED
+ *     BOUNDRELAXED    = SCIP_EVENTTYPE_BOUNDRELAXED
+ *     BOUNDCHANGED    = SCIP_EVENTTYPE_BOUNDCHANGED             # <<<<<<<<<<<<<<
+ *     GHOLECHANGED    = SCIP_EVENTTYPE_GHOLECHANGED
+ *     LHOLECHANGED    = SCIP_EVENTTYPE_LHOLECHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_BOUNDCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_BOUNDCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 217, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":218
+ *     BOUNDRELAXED    = SCIP_EVENTTYPE_BOUNDRELAXED
+ *     BOUNDCHANGED    = SCIP_EVENTTYPE_BOUNDCHANGED
+ *     GHOLECHANGED    = SCIP_EVENTTYPE_GHOLECHANGED             # <<<<<<<<<<<<<<
+ *     LHOLECHANGED    = SCIP_EVENTTYPE_LHOLECHANGED
+ *     HOLECHANGED     = SCIP_EVENTTYPE_HOLECHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_GHOLECHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_GHOLECHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 218, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":219
+ *     BOUNDCHANGED    = SCIP_EVENTTYPE_BOUNDCHANGED
+ *     GHOLECHANGED    = SCIP_EVENTTYPE_GHOLECHANGED
+ *     LHOLECHANGED    = SCIP_EVENTTYPE_LHOLECHANGED             # <<<<<<<<<<<<<<
+ *     HOLECHANGED     = SCIP_EVENTTYPE_HOLECHANGED
+ *     DOMCHANGED      = SCIP_EVENTTYPE_DOMCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_LHOLECHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_LHOLECHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 219, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":220
+ *     GHOLECHANGED    = SCIP_EVENTTYPE_GHOLECHANGED
+ *     LHOLECHANGED    = SCIP_EVENTTYPE_LHOLECHANGED
+ *     HOLECHANGED     = SCIP_EVENTTYPE_HOLECHANGED             # <<<<<<<<<<<<<<
+ *     DOMCHANGED      = SCIP_EVENTTYPE_DOMCHANGED
+ *     VARCHANGED      = SCIP_EVENTTYPE_VARCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_HOLECHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_HOLECHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 220, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":221
+ *     LHOLECHANGED    = SCIP_EVENTTYPE_LHOLECHANGED
+ *     HOLECHANGED     = SCIP_EVENTTYPE_HOLECHANGED
+ *     DOMCHANGED      = SCIP_EVENTTYPE_DOMCHANGED             # <<<<<<<<<<<<<<
+ *     VARCHANGED      = SCIP_EVENTTYPE_VARCHANGED
+ *     VAREVENT        = SCIP_EVENTTYPE_VAREVENT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_DOMCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_DOMCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 221, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":222
+ *     HOLECHANGED     = SCIP_EVENTTYPE_HOLECHANGED
+ *     DOMCHANGED      = SCIP_EVENTTYPE_DOMCHANGED
+ *     VARCHANGED      = SCIP_EVENTTYPE_VARCHANGED             # <<<<<<<<<<<<<<
+ *     VAREVENT        = SCIP_EVENTTYPE_VAREVENT
+ *     NODESOLVED      = SCIP_EVENTTYPE_NODESOLVED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_VARCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_VARCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 222, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":223
+ *     DOMCHANGED      = SCIP_EVENTTYPE_DOMCHANGED
+ *     VARCHANGED      = SCIP_EVENTTYPE_VARCHANGED
+ *     VAREVENT        = SCIP_EVENTTYPE_VAREVENT             # <<<<<<<<<<<<<<
+ *     NODESOLVED      = SCIP_EVENTTYPE_NODESOLVED
+ *     NODEEVENT       = SCIP_EVENTTYPE_NODEEVENT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_VAREVENT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_VAREVENT, __pyx_t_2) < 0) __PYX_ERR(0, 223, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":224
+ *     VARCHANGED      = SCIP_EVENTTYPE_VARCHANGED
+ *     VAREVENT        = SCIP_EVENTTYPE_VAREVENT
+ *     NODESOLVED      = SCIP_EVENTTYPE_NODESOLVED             # <<<<<<<<<<<<<<
+ *     NODEEVENT       = SCIP_EVENTTYPE_NODEEVENT
+ *     SOLFOUND        = SCIP_EVENTTYPE_SOLFOUND
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_NODESOLVED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_NODESOLVED, __pyx_t_2) < 0) __PYX_ERR(0, 224, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":225
+ *     VAREVENT        = SCIP_EVENTTYPE_VAREVENT
+ *     NODESOLVED      = SCIP_EVENTTYPE_NODESOLVED
+ *     NODEEVENT       = SCIP_EVENTTYPE_NODEEVENT             # <<<<<<<<<<<<<<
+ *     SOLFOUND        = SCIP_EVENTTYPE_SOLFOUND
+ *     SOLEVENT        = SCIP_EVENTTYPE_SOLEVENT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_NODEEVENT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 225, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_NODEEVENT, __pyx_t_2) < 0) __PYX_ERR(0, 225, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":226
+ *     NODESOLVED      = SCIP_EVENTTYPE_NODESOLVED
+ *     NODEEVENT       = SCIP_EVENTTYPE_NODEEVENT
+ *     SOLFOUND        = SCIP_EVENTTYPE_SOLFOUND             # <<<<<<<<<<<<<<
+ *     SOLEVENT        = SCIP_EVENTTYPE_SOLEVENT
+ *     ROWCHANGED      = SCIP_EVENTTYPE_ROWCHANGED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_SOLFOUND); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_SOLFOUND, __pyx_t_2) < 0) __PYX_ERR(0, 226, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":227
+ *     NODEEVENT       = SCIP_EVENTTYPE_NODEEVENT
+ *     SOLFOUND        = SCIP_EVENTTYPE_SOLFOUND
+ *     SOLEVENT        = SCIP_EVENTTYPE_SOLEVENT             # <<<<<<<<<<<<<<
+ *     ROWCHANGED      = SCIP_EVENTTYPE_ROWCHANGED
+ *     ROWEVENT        = SCIP_EVENTTYPE_ROWEVENT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_SOLEVENT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_SOLEVENT, __pyx_t_2) < 0) __PYX_ERR(0, 227, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":228
+ *     SOLFOUND        = SCIP_EVENTTYPE_SOLFOUND
+ *     SOLEVENT        = SCIP_EVENTTYPE_SOLEVENT
+ *     ROWCHANGED      = SCIP_EVENTTYPE_ROWCHANGED             # <<<<<<<<<<<<<<
+ *     ROWEVENT        = SCIP_EVENTTYPE_ROWEVENT
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWCHANGED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWCHANGED, __pyx_t_2) < 0) __PYX_ERR(0, 228, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":229
+ *     SOLEVENT        = SCIP_EVENTTYPE_SOLEVENT
+ *     ROWCHANGED      = SCIP_EVENTTYPE_ROWCHANGED
+ *     ROWEVENT        = SCIP_EVENTTYPE_ROWEVENT             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE_ROWEVENT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_ROWEVENT, __pyx_t_2) < 0) __PYX_ERR(0, 229, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_EVENTTYPE___reduce_cytho, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__461)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_EVENTTYPE, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_EVENTTYPE__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_17PY_SCIP_EVENTTYPE_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_EVENTTYPE___setstate_cyt, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__462)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_EVENTTYPE);
+
+  /* "src/pyscipopt/scip.pxi":233
+ * 
+ * cdef class PY_SCIP_LPSOLSTAT:
+ *     NOTSOLVED    = SCIP_LPSOLSTAT_NOTSOLVED             # <<<<<<<<<<<<<<
+ *     OPTIMAL      = SCIP_LPSOLSTAT_OPTIMAL
+ *     INFEASIBLE   = SCIP_LPSOLSTAT_INFEASIBLE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT_NOTSOLVED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 233, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_NOTSOLVED, __pyx_t_2) < 0) __PYX_ERR(0, 233, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "src/pyscipopt/scip.pxi":234
+ * cdef class PY_SCIP_LPSOLSTAT:
+ *     NOTSOLVED    = SCIP_LPSOLSTAT_NOTSOLVED
+ *     OPTIMAL      = SCIP_LPSOLSTAT_OPTIMAL             # <<<<<<<<<<<<<<
+ *     INFEASIBLE   = SCIP_LPSOLSTAT_INFEASIBLE
+ *     UNBOUNDEDRAY = SCIP_LPSOLSTAT_UNBOUNDEDRAY
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT_OPTIMAL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_OPTIMAL, __pyx_t_2) < 0) __PYX_ERR(0, 234, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "src/pyscipopt/scip.pxi":235
+ *     NOTSOLVED    = SCIP_LPSOLSTAT_NOTSOLVED
+ *     OPTIMAL      = SCIP_LPSOLSTAT_OPTIMAL
+ *     INFEASIBLE   = SCIP_LPSOLSTAT_INFEASIBLE             # <<<<<<<<<<<<<<
+ *     UNBOUNDEDRAY = SCIP_LPSOLSTAT_UNBOUNDEDRAY
+ *     OBJLIMIT     = SCIP_LPSOLSTAT_OBJLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT_INFEASIBLE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_INFEASIBLE, __pyx_t_2) < 0) __PYX_ERR(0, 235, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "src/pyscipopt/scip.pxi":236
+ *     OPTIMAL      = SCIP_LPSOLSTAT_OPTIMAL
+ *     INFEASIBLE   = SCIP_LPSOLSTAT_INFEASIBLE
+ *     UNBOUNDEDRAY = SCIP_LPSOLSTAT_UNBOUNDEDRAY             # <<<<<<<<<<<<<<
+ *     OBJLIMIT     = SCIP_LPSOLSTAT_OBJLIMIT
+ *     ITERLIMIT    = SCIP_LPSOLSTAT_ITERLIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT_UNBOUNDEDRAY); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_UNBOUNDEDRAY, __pyx_t_2) < 0) __PYX_ERR(0, 236, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "src/pyscipopt/scip.pxi":237
+ *     INFEASIBLE   = SCIP_LPSOLSTAT_INFEASIBLE
+ *     UNBOUNDEDRAY = SCIP_LPSOLSTAT_UNBOUNDEDRAY
+ *     OBJLIMIT     = SCIP_LPSOLSTAT_OBJLIMIT             # <<<<<<<<<<<<<<
+ *     ITERLIMIT    = SCIP_LPSOLSTAT_ITERLIMIT
+ *     TIMELIMIT    = SCIP_LPSOLSTAT_TIMELIMIT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT_OBJLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_OBJLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 237, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "src/pyscipopt/scip.pxi":238
+ *     UNBOUNDEDRAY = SCIP_LPSOLSTAT_UNBOUNDEDRAY
+ *     OBJLIMIT     = SCIP_LPSOLSTAT_OBJLIMIT
+ *     ITERLIMIT    = SCIP_LPSOLSTAT_ITERLIMIT             # <<<<<<<<<<<<<<
+ *     TIMELIMIT    = SCIP_LPSOLSTAT_TIMELIMIT
+ *     ERROR        = SCIP_LPSOLSTAT_ERROR
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT_ITERLIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_ITERLIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 238, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "src/pyscipopt/scip.pxi":239
+ *     OBJLIMIT     = SCIP_LPSOLSTAT_OBJLIMIT
+ *     ITERLIMIT    = SCIP_LPSOLSTAT_ITERLIMIT
+ *     TIMELIMIT    = SCIP_LPSOLSTAT_TIMELIMIT             # <<<<<<<<<<<<<<
+ *     ERROR        = SCIP_LPSOLSTAT_ERROR
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT_TIMELIMIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_TIMELIMIT, __pyx_t_2) < 0) __PYX_ERR(0, 239, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "src/pyscipopt/scip.pxi":240
+ *     ITERLIMIT    = SCIP_LPSOLSTAT_ITERLIMIT
+ *     TIMELIMIT    = SCIP_LPSOLSTAT_TIMELIMIT
+ *     ERROR        = SCIP_LPSOLSTAT_ERROR             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_BRANCHDIR:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT_ERROR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_ERROR, __pyx_t_2) < 0) __PYX_ERR(0, 240, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_LPSOLSTAT___reduce_cytho, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__463)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_LPSOLSTAT, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_17PY_SCIP_LPSOLSTAT_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_LPSOLSTAT___setstate_cyt, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__464)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_LPSOLSTAT);
+
+  /* "src/pyscipopt/scip.pxi":243
+ * 
+ * cdef class PY_SCIP_BRANCHDIR:
+ *     DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS             # <<<<<<<<<<<<<<
+ *     UPWARDS   = SCIP_BRANCHDIR_UPWARDS
+ *     FIXED     = SCIP_BRANCHDIR_FIXED
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_BRANCHDIR(SCIP_BRANCHDIR_DOWNWARDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, __pyx_n_s_DOWNWARDS, __pyx_t_2) < 0) __PYX_ERR(0, 243, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR);
+
+  /* "src/pyscipopt/scip.pxi":244
+ * cdef class PY_SCIP_BRANCHDIR:
+ *     DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS
+ *     UPWARDS   = SCIP_BRANCHDIR_UPWARDS             # <<<<<<<<<<<<<<
+ *     FIXED     = SCIP_BRANCHDIR_FIXED
+ *     AUTO      = SCIP_BRANCHDIR_AUTO
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_BRANCHDIR(SCIP_BRANCHDIR_UPWARDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, __pyx_n_s_UPWARDS, __pyx_t_2) < 0) __PYX_ERR(0, 244, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR);
+
+  /* "src/pyscipopt/scip.pxi":245
+ *     DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS
+ *     UPWARDS   = SCIP_BRANCHDIR_UPWARDS
+ *     FIXED     = SCIP_BRANCHDIR_FIXED             # <<<<<<<<<<<<<<
+ *     AUTO      = SCIP_BRANCHDIR_AUTO
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_BRANCHDIR(SCIP_BRANCHDIR_FIXED); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 245, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, __pyx_n_s_FIXED, __pyx_t_2) < 0) __PYX_ERR(0, 245, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR);
+
+  /* "src/pyscipopt/scip.pxi":246
+ *     UPWARDS   = SCIP_BRANCHDIR_UPWARDS
+ *     FIXED     = SCIP_BRANCHDIR_FIXED
+ *     AUTO      = SCIP_BRANCHDIR_AUTO             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_BENDERSENFOTYPE:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_BRANCHDIR(SCIP_BRANCHDIR_AUTO); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, __pyx_n_s_AUTO, __pyx_t_2) < 0) __PYX_ERR(0, 246, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_BRANCHDIR___reduce_cytho, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__465)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_BRANCHDIR, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_BRANCHDIR__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_17PY_SCIP_BRANCHDIR_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_BRANCHDIR___setstate_cyt, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__466)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BRANCHDIR);
+
+  /* "src/pyscipopt/scip.pxi":249
+ * 
+ * cdef class PY_SCIP_BENDERSENFOTYPE:
+ *     LP     = SCIP_BENDERSENFOTYPE_LP             # <<<<<<<<<<<<<<
+ *     RELAX  = SCIP_BENDERSENFOTYPE_RELAX
+ *     PSEUDO = SCIP_BENDERSENFOTYPE_PSEUDO
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(SCIP_BENDERSENFOTYPE_LP); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 249, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, __pyx_n_s_LP, __pyx_t_2) < 0) __PYX_ERR(0, 249, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE);
+
+  /* "src/pyscipopt/scip.pxi":250
+ * cdef class PY_SCIP_BENDERSENFOTYPE:
+ *     LP     = SCIP_BENDERSENFOTYPE_LP
+ *     RELAX  = SCIP_BENDERSENFOTYPE_RELAX             # <<<<<<<<<<<<<<
+ *     PSEUDO = SCIP_BENDERSENFOTYPE_PSEUDO
+ *     CHECK  = SCIP_BENDERSENFOTYPE_CHECK
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(SCIP_BENDERSENFOTYPE_RELAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, __pyx_n_s_RELAX, __pyx_t_2) < 0) __PYX_ERR(0, 250, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE);
+
+  /* "src/pyscipopt/scip.pxi":251
+ *     LP     = SCIP_BENDERSENFOTYPE_LP
+ *     RELAX  = SCIP_BENDERSENFOTYPE_RELAX
+ *     PSEUDO = SCIP_BENDERSENFOTYPE_PSEUDO             # <<<<<<<<<<<<<<
+ *     CHECK  = SCIP_BENDERSENFOTYPE_CHECK
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(SCIP_BENDERSENFOTYPE_PSEUDO); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 251, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, __pyx_n_s_PSEUDO, __pyx_t_2) < 0) __PYX_ERR(0, 251, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE);
+
+  /* "src/pyscipopt/scip.pxi":252
+ *     RELAX  = SCIP_BENDERSENFOTYPE_RELAX
+ *     PSEUDO = SCIP_BENDERSENFOTYPE_PSEUDO
+ *     CHECK  = SCIP_BENDERSENFOTYPE_CHECK             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PY_SCIP_ROWORIGINTYPE:
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(SCIP_BENDERSENFOTYPE_CHECK); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 252, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, __pyx_n_s_CHECK, __pyx_t_2) < 0) __PYX_ERR(0, 252, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_BENDERSENFOTYPE___reduce, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__467)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_23PY_SCIP_BENDERSENFOTYPE_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_BENDERSENFOTYPE___setsta, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__468)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE);
+
+  /* "src/pyscipopt/scip.pxi":255
+ * 
+ * cdef class PY_SCIP_ROWORIGINTYPE:
+ *     UNSPEC = SCIP_ROWORIGINTYPE_UNSPEC             # <<<<<<<<<<<<<<
+ *     CONS   = SCIP_ROWORIGINTYPE_CONS
+ *     SEPA   = SCIP_ROWORIGINTYPE_SEPA
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_ROWORIGINTYPE(SCIP_ROWORIGINTYPE_UNSPEC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, __pyx_n_s_UNSPEC, __pyx_t_2) < 0) __PYX_ERR(0, 255, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE);
+
+  /* "src/pyscipopt/scip.pxi":256
+ * cdef class PY_SCIP_ROWORIGINTYPE:
+ *     UNSPEC = SCIP_ROWORIGINTYPE_UNSPEC
+ *     CONS   = SCIP_ROWORIGINTYPE_CONS             # <<<<<<<<<<<<<<
+ *     SEPA   = SCIP_ROWORIGINTYPE_SEPA
+ *     REOPT  = SCIP_ROWORIGINTYPE_REOPT
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_ROWORIGINTYPE(SCIP_ROWORIGINTYPE_CONS); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 256, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, __pyx_n_s_CONS, __pyx_t_2) < 0) __PYX_ERR(0, 256, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE);
+
+  /* "src/pyscipopt/scip.pxi":257
+ *     UNSPEC = SCIP_ROWORIGINTYPE_UNSPEC
+ *     CONS   = SCIP_ROWORIGINTYPE_CONS
+ *     SEPA   = SCIP_ROWORIGINTYPE_SEPA             # <<<<<<<<<<<<<<
+ *     REOPT  = SCIP_ROWORIGINTYPE_REOPT
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_ROWORIGINTYPE(SCIP_ROWORIGINTYPE_SEPA); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 257, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, __pyx_n_s_SEPA, __pyx_t_2) < 0) __PYX_ERR(0, 257, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE);
+
+  /* "src/pyscipopt/scip.pxi":258
+ *     CONS   = SCIP_ROWORIGINTYPE_CONS
+ *     SEPA   = SCIP_ROWORIGINTYPE_SEPA
+ *     REOPT  = SCIP_ROWORIGINTYPE_REOPT             # <<<<<<<<<<<<<<
+ * 
+ * def PY_SCIP_CALL(SCIP_RETCODE rc):
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_ROWORIGINTYPE(SCIP_ROWORIGINTYPE_REOPT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, __pyx_n_s_REOPT, __pyx_t_2) < 0) __PYX_ERR(0, 258, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     cdef tuple state
+ *     cdef object _dict
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_1__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_ROWORIGINTYPE___reduce_c, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__469)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE);
+
+  /* "(tree fragment)":16
+ *     else:
+ *         return __pyx_unpickle_PY_SCIP_ROWORIGINTYPE, (type(self), 0xe3b0c44, state)
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_unpickle_PY_SCIP_ROWORIGINTYPE__set_state(self, __pyx_state)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_21PY_SCIP_ROWORIGINTYPE_3__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_PY_SCIP_ROWORIGINTYPE___setstate, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__470)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 16, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_PY_SCIP_ROWORIGINTYPE);
+
+  /* "src/pyscipopt/scip.pxi":260
+ *     REOPT  = SCIP_ROWORIGINTYPE_REOPT
+ * 
+ * def PY_SCIP_CALL(SCIP_RETCODE rc):             # <<<<<<<<<<<<<<
+ *     if rc == SCIP_OKAY:
+ *         pass
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_27PY_SCIP_CALL, 0, __pyx_n_s_PY_SCIP_CALL, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__472)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PY_SCIP_CALL, __pyx_t_2) < 0) __PYX_ERR(0, 260, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":312
+ *         return event
+ * 
+ *     def getType(self):             # <<<<<<<<<<<<<<
+ *         """gets type of event"""
+ *         return SCIPeventGetType(self.event)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_1getType, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_getType, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__473)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event, __pyx_n_s_getType, __pyx_t_2) < 0) __PYX_ERR(0, 312, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Event);
+
+  /* "src/pyscipopt/scip.pxi":316
+ *         return SCIPeventGetType(self.event)
+ * 
+ *     def getName(self):             # <<<<<<<<<<<<<<
+ *         """gets name of event"""
+ *         if not EventNames:
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_3getName, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_getName, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__474)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 316, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event, __pyx_n_s_getName, __pyx_t_2) < 0) __PYX_ERR(0, 316, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Event);
+
+  /* "src/pyscipopt/scip.pxi":322
+ *         return EventNames[self.getType()]
+ * 
+ *     def _getEventNames(self):             # <<<<<<<<<<<<<<
+ *         """gets event names"""
+ *         for name in dir(PY_SCIP_EVENTTYPE):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_5_getEventNames, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event__getEventNames, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__476)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event, __pyx_n_s_getEventNames, __pyx_t_2) < 0) __PYX_ERR(0, 322, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Event);
+
+  /* "src/pyscipopt/scip.pxi":335
+ *         return self.getName()
+ * 
+ *     def getNewBound(self):             # <<<<<<<<<<<<<<
+ *         """gets new bound for a bound change event"""
+ *         return SCIPeventGetNewbound(self.event)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_11getNewBound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_getNewBound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__477)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 335, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event, __pyx_n_s_getNewBound, __pyx_t_2) < 0) __PYX_ERR(0, 335, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Event);
+
+  /* "src/pyscipopt/scip.pxi":339
+ *         return SCIPeventGetNewbound(self.event)
+ * 
+ *     def getOldBound(self):             # <<<<<<<<<<<<<<
+ *         """gets old bound for a bound change event"""
+ *         return SCIPeventGetOldbound(self.event)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_13getOldBound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_getOldBound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__478)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 339, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event, __pyx_n_s_getOldBound, __pyx_t_2) < 0) __PYX_ERR(0, 339, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Event);
+
+  /* "src/pyscipopt/scip.pxi":343
+ *         return SCIPeventGetOldbound(self.event)
+ * 
+ *     def getVar(self):             # <<<<<<<<<<<<<<
+ *         """gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)"""
+ *         cdef SCIP_VAR* var = SCIPeventGetVar(self.event)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_15getVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_getVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__480)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 343, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event, __pyx_n_s_getVar, __pyx_t_2) < 0) __PYX_ERR(0, 343, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Event);
+
+  /* "src/pyscipopt/scip.pxi":348
+ *         return Variable.create(var)
+ * 
+ *     def getNode(self):             # <<<<<<<<<<<<<<
+ *         """gets node for a node or LP event"""
+ *         cdef SCIP_NODE* node = SCIPeventGetNode(self.event)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_17getNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_getNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__482)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 348, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event, __pyx_n_s_getNode, __pyx_t_2) < 0) __PYX_ERR(0, 348, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Event);
+
+  /* "src/pyscipopt/scip.pxi":353
+ *         return Node.create(node)
+ * 
+ *     def getRow(self):             # <<<<<<<<<<<<<<
+ *         """gets row for a row event"""
+ *         cdef SCIP_ROW* row = SCIPeventGetRow(self.event)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_19getRow, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event_getRow, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__484)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 353, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Event, __pyx_n_s_getRow, __pyx_t_2) < 0) __PYX_ERR(0, 353, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Event);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.event cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_25__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__485)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.event cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.event cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Event_27__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Event___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__486)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":376
+ *         return col
+ * 
+ *     def getLPPos(self):             # <<<<<<<<<<<<<<
+ *         """gets position of column in current LP, or -1 if it is not in LP"""
+ *         return SCIPcolGetLPPos(self.scip_col)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_1getLPPos, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column_getLPPos, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__487)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 376, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column, __pyx_n_s_getLPPos, __pyx_t_2) < 0) __PYX_ERR(0, 376, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Column);
+
+  /* "src/pyscipopt/scip.pxi":380
+ *         return SCIPcolGetLPPos(self.scip_col)
+ * 
+ *     def getBasisStatus(self):             # <<<<<<<<<<<<<<
+ *         """gets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP"""
+ *         cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_3getBasisStatus, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column_getBasisStatus, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__489)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 380, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column, __pyx_n_s_getBasisStatus, __pyx_t_2) < 0) __PYX_ERR(0, 380, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Column);
+
+  /* "src/pyscipopt/scip.pxi":394
+ *             raise Exception('SCIP returned unknown base status!')
+ * 
+ *     def isIntegral(self):             # <<<<<<<<<<<<<<
+ *         """returns whether the associated variable is of integral type (binary, integer, implicit integer)"""
+ *         return SCIPcolIsIntegral(self.scip_col)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_5isIntegral, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column_isIntegral, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__490)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column, __pyx_n_s_isIntegral, __pyx_t_2) < 0) __PYX_ERR(0, 394, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Column);
+
+  /* "src/pyscipopt/scip.pxi":398
+ *         return SCIPcolIsIntegral(self.scip_col)
+ * 
+ *     def getVar(self):             # <<<<<<<<<<<<<<
+ *         """gets variable this column represents"""
+ *         cdef SCIP_VAR* var = SCIPcolGetVar(self.scip_col)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_7getVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column_getVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__491)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 398, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column, __pyx_n_s_getVar, __pyx_t_2) < 0) __PYX_ERR(0, 398, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Column);
+
+  /* "src/pyscipopt/scip.pxi":403
+ *         return Variable.create(var)
+ * 
+ *     def getPrimsol(self):             # <<<<<<<<<<<<<<
+ *         """gets the primal LP solution of a column"""
+ *         return SCIPcolGetPrimsol(self.scip_col)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_9getPrimsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column_getPrimsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__492)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 403, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column, __pyx_n_s_getPrimsol, __pyx_t_2) < 0) __PYX_ERR(0, 403, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Column);
+
+  /* "src/pyscipopt/scip.pxi":407
+ *         return SCIPcolGetPrimsol(self.scip_col)
+ * 
+ *     def getLb(self):             # <<<<<<<<<<<<<<
+ *         """gets lower bound of column"""
+ *         return SCIPcolGetLb(self.scip_col)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_11getLb, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column_getLb, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__493)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column, __pyx_n_s_getLb, __pyx_t_2) < 0) __PYX_ERR(0, 407, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Column);
+
+  /* "src/pyscipopt/scip.pxi":411
+ *         return SCIPcolGetLb(self.scip_col)
+ * 
+ *     def getUb(self):             # <<<<<<<<<<<<<<
+ *         """gets upper bound of column"""
+ *         return SCIPcolGetUb(self.scip_col)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_13getUb, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column_getUb, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__494)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 411, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column, __pyx_n_s_getUb, __pyx_t_2) < 0) __PYX_ERR(0, 411, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Column);
+
+  /* "src/pyscipopt/scip.pxi":415
+ *         return SCIPcolGetUb(self.scip_col)
+ * 
+ *     def getObjCoeff(self):             # <<<<<<<<<<<<<<
+ *         """gets objective value coefficient of a column"""
+ *         return SCIPcolGetObj(self.scip_col)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_15getObjCoeff, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column_getObjCoeff, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__495)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 415, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Column, __pyx_n_s_getObjCoeff, __pyx_t_2) < 0) __PYX_ERR(0, 415, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Column);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_col cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_21__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__496)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip_col cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_col cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_6Column_23__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Column___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__497)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":442
+ *             return cname.decode('utf-8')
+ * 
+ *     def getLhs(self):             # <<<<<<<<<<<<<<
+ *         """returns the left hand side of row"""
+ *         return SCIProwGetLhs(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_1getLhs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getLhs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__498)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 442, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getLhs, __pyx_t_2) < 0) __PYX_ERR(0, 442, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":446
+ *         return SCIProwGetLhs(self.scip_row)
+ * 
+ *     def getRhs(self):             # <<<<<<<<<<<<<<
+ *         """returns the right hand side of row"""
+ *         return SCIProwGetRhs(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_3getRhs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getRhs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__499)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 446, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getRhs, __pyx_t_2) < 0) __PYX_ERR(0, 446, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":450
+ *         return SCIProwGetRhs(self.scip_row)
+ * 
+ *     def getConstant(self):             # <<<<<<<<<<<<<<
+ *         """gets constant shift of row"""
+ *         return SCIProwGetConstant(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_5getConstant, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getConstant, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__500)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 450, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getConstant, __pyx_t_2) < 0) __PYX_ERR(0, 450, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":454
+ *         return SCIProwGetConstant(self.scip_row)
+ * 
+ *     def getLPPos(self):             # <<<<<<<<<<<<<<
+ *         """gets position of row in current LP, or -1 if it is not in LP"""
+ *         return SCIProwGetLPPos(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_7getLPPos, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getLPPos, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__501)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getLPPos, __pyx_t_2) < 0) __PYX_ERR(0, 454, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":458
+ *         return SCIProwGetLPPos(self.scip_row)
+ * 
+ *     def getBasisStatus(self):             # <<<<<<<<<<<<<<
+ *         """gets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP"""
+ *         cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_9getBasisStatus, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getBasisStatus, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__502)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 458, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getBasisStatus, __pyx_t_2) < 0) __PYX_ERR(0, 458, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":473
+ *             raise Exception('SCIP returned unknown base status!')
+ * 
+ *     def isIntegral(self):             # <<<<<<<<<<<<<<
+ *         """returns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution """
+ *         return SCIProwIsIntegral(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_11isIntegral, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_isIntegral, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__503)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 473, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_isIntegral, __pyx_t_2) < 0) __PYX_ERR(0, 473, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":477
+ *         return SCIProwIsIntegral(self.scip_row)
+ * 
+ *     def isLocal(self):             # <<<<<<<<<<<<<<
+ *         """returns TRUE iff the row is only valid locally """
+ *         return SCIProwIsLocal(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_13isLocal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_isLocal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__504)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 477, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_isLocal, __pyx_t_2) < 0) __PYX_ERR(0, 477, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":481
+ *         return SCIProwIsLocal(self.scip_row)
+ * 
+ *     def isModifiable(self):             # <<<<<<<<<<<<<<
+ *         """returns TRUE iff row is modifiable during node processing (subject to column generation) """
+ *         return SCIProwIsModifiable(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_15isModifiable, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_isModifiable, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__505)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 481, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_isModifiable, __pyx_t_2) < 0) __PYX_ERR(0, 481, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":485
+ *         return SCIProwIsModifiable(self.scip_row)
+ * 
+ *     def isRemovable(self):             # <<<<<<<<<<<<<<
+ *         """returns TRUE iff row is removable from the LP (due to aging or cleanup)"""
+ *         return SCIProwIsRemovable(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_17isRemovable, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_isRemovable, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__506)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 485, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_isRemovable, __pyx_t_2) < 0) __PYX_ERR(0, 485, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":489
+ *         return SCIProwIsRemovable(self.scip_row)
+ * 
+ *     def isInGlobalCutpool(self):             # <<<<<<<<<<<<<<
+ *         """return TRUE iff row is a member of the global cut pool"""
+ *         return SCIProwIsInGlobalCutpool(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_19isInGlobalCutpool, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_isInGlobalCutpool, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__507)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 489, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_isInGlobalCutpool, __pyx_t_2) < 0) __PYX_ERR(0, 489, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":493
+ *         return SCIProwIsInGlobalCutpool(self.scip_row)
+ * 
+ *     def getOrigintype(self):             # <<<<<<<<<<<<<<
+ *         """returns type of origin that created the row"""
+ *         return SCIProwGetOrigintype(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_21getOrigintype, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getOrigintype, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__508)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 493, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getOrigintype, __pyx_t_2) < 0) __PYX_ERR(0, 493, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":497
+ *         return SCIProwGetOrigintype(self.scip_row)
+ * 
+ *     def getConsOriginConshdlrtype(self):             # <<<<<<<<<<<<<<
+ *         """returns type of constraint handler that created the row"""
+ *         cdef SCIP_CONS* scip_con = SCIProwGetOriginCons(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_23getConsOriginConshdlrtype, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getConsOriginConshdlrtype, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__510)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 497, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getConsOriginConshdlrtype, __pyx_t_2) < 0) __PYX_ERR(0, 497, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":502
+ *         return bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(scip_con))).decode('UTF-8')
+ * 
+ *     def getNNonz(self):             # <<<<<<<<<<<<<<
+ *         """get number of nonzero entries in row vector"""
+ *         return SCIProwGetNNonz(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_25getNNonz, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getNNonz, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__511)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 502, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getNNonz, __pyx_t_2) < 0) __PYX_ERR(0, 502, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":506
+ *         return SCIProwGetNNonz(self.scip_row)
+ * 
+ *     def getNLPNonz(self):             # <<<<<<<<<<<<<<
+ *         """get number of nonzero entries in row vector that correspond to columns currently in the SCIP LP"""
+ *         return SCIProwGetNLPNonz(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_27getNLPNonz, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getNLPNonz, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__512)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 506, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getNLPNonz, __pyx_t_2) < 0) __PYX_ERR(0, 506, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":510
+ *         return SCIProwGetNLPNonz(self.scip_row)
+ * 
+ *     def getCols(self):             # <<<<<<<<<<<<<<
+ *         """gets list with columns of nonzero entries"""
+ *         cdef SCIP_COL** cols = SCIProwGetCols(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_29getCols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getCols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__514)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 510, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getCols, __pyx_t_2) < 0) __PYX_ERR(0, 510, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":515
+ *         return [Column.create(cols[i]) for i in range(self.getNNonz())]
+ * 
+ *     def getVals(self):             # <<<<<<<<<<<<<<
+ *         """gets list with coefficients of nonzero entries"""
+ *         cdef SCIP_Real* vals = SCIProwGetVals(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_31getVals, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getVals, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__516)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 515, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getVals, __pyx_t_2) < 0) __PYX_ERR(0, 515, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "src/pyscipopt/scip.pxi":520
+ *         return [vals[i] for i in range(self.getNNonz())]
+ * 
+ *     def getNorm(self):             # <<<<<<<<<<<<<<
+ *         """gets Euclidean norm of row vector """
+ *         return SCIProwGetNorm(self.scip_row)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_33getNorm, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row_getNorm, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__517)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 520, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Row, __pyx_n_s_getNorm, __pyx_t_2) < 0) __PYX_ERR(0, 520, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Row);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_row cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_39__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__518)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip_row cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_row cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_3Row_41__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Row___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__519)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":547
+ *             return cname.decode('utf-8')
+ * 
+ *     def getConstant(self):             # <<<<<<<<<<<<<<
+ *         """returns the constant of a nonlinear row"""
+ *         return SCIPnlrowGetConstant(self.scip_nlrow)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5NLRow_1getConstant, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_NLRow_getConstant, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__520)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 547, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_NLRow, __pyx_n_s_getConstant, __pyx_t_2) < 0) __PYX_ERR(0, 547, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_NLRow);
+
+  /* "src/pyscipopt/scip.pxi":551
+ *         return SCIPnlrowGetConstant(self.scip_nlrow)
+ * 
+ *     def getLinearTerms(self):             # <<<<<<<<<<<<<<
+ *         """returns a list of tuples (var, coef) representing the linear part of a nonlinear row"""
+ *         cdef SCIP_VAR** linvars = SCIPnlrowGetLinearVars(self.scip_nlrow)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5NLRow_3getLinearTerms, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_NLRow_getLinearTerms, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__522)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 551, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_NLRow, __pyx_n_s_getLinearTerms, __pyx_t_2) < 0) __PYX_ERR(0, 551, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_NLRow);
+
+  /* "src/pyscipopt/scip.pxi":558
+ *         return [(Variable.create(linvars[i]), lincoefs[i]) for i in range(nlinvars)]
+ * 
+ *     def getLhs(self):             # <<<<<<<<<<<<<<
+ *         """returns the left hand side of a nonlinear row"""
+ *         return SCIPnlrowGetLhs(self.scip_nlrow)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5NLRow_5getLhs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_NLRow_getLhs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__523)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 558, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_NLRow, __pyx_n_s_getLhs, __pyx_t_2) < 0) __PYX_ERR(0, 558, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_NLRow);
+
+  /* "src/pyscipopt/scip.pxi":562
+ *         return SCIPnlrowGetLhs(self.scip_nlrow)
+ * 
+ *     def getRhs(self):             # <<<<<<<<<<<<<<
+ *         """returns the right hand side of a nonlinear row"""
+ *         return SCIPnlrowGetRhs(self.scip_nlrow)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5NLRow_7getRhs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_NLRow_getRhs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__524)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 562, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_NLRow, __pyx_n_s_getRhs, __pyx_t_2) < 0) __PYX_ERR(0, 562, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_NLRow);
+
+  /* "src/pyscipopt/scip.pxi":566
+ *         return SCIPnlrowGetRhs(self.scip_nlrow)
+ * 
+ *     def getDualsol(self):             # <<<<<<<<<<<<<<
+ *         """gets the dual NLP solution of a nonlinear row"""
+ *         return SCIPnlrowGetDualsol(self.scip_nlrow)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5NLRow_9getDualsol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_NLRow_getDualsol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__525)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 566, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_NLRow, __pyx_n_s_getDualsol, __pyx_t_2) < 0) __PYX_ERR(0, 566, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_NLRow);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5NLRow_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_NLRow___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__526)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_nlrow cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5NLRow_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_NLRow___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__527)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":602
+ *         return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0)
+ * 
+ *     def _evaluate(self, term):             # <<<<<<<<<<<<<<
+ *         self._checkStage("SCIPgetSolVal")
+ *         result = 1
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Solution_5_evaluate, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Solution__evaluate, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__529)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 602, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Solution, __pyx_n_s_evaluate, __pyx_t_2) < 0) __PYX_ERR(0, 602, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Solution);
+
+  /* "src/pyscipopt/scip.pxi":627
+ *         return str(vals)
+ * 
+ *     def _checkStage(self, method):             # <<<<<<<<<<<<<<
+ *         if method in ["SCIPgetSolVal", "getSolObjVal"]:
+ *             if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING:
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Solution_11_checkStage, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Solution__checkStage, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__531)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 627, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Solution, __pyx_n_s_checkStage, __pyx_t_2) < 0) __PYX_ERR(0, 627, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Solution);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Solution_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Solution___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__532)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip,self.sol cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Solution_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Solution___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__533)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":644
+ *         return boundchg
+ * 
+ *     def getNewBound(self):             # <<<<<<<<<<<<<<
+ *         """Returns the new value of the bound in the bound change."""
+ *         return SCIPboundchgGetNewbound(self.scip_boundchg)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_11BoundChange_1getNewBound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_BoundChange_getNewBound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__534)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 644, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_BoundChange, __pyx_n_s_getNewBound, __pyx_t_2) < 0) __PYX_ERR(0, 644, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_BoundChange);
+
+  /* "src/pyscipopt/scip.pxi":648
+ *         return SCIPboundchgGetNewbound(self.scip_boundchg)
+ * 
+ *     def getVar(self):             # <<<<<<<<<<<<<<
+ *         """Returns the variable of the bound change."""
+ *         return Variable.create(SCIPboundchgGetVar(self.scip_boundchg))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_11BoundChange_3getVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_BoundChange_getVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__535)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 648, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_BoundChange, __pyx_n_s_getVar, __pyx_t_2) < 0) __PYX_ERR(0, 648, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_BoundChange);
+
+  /* "src/pyscipopt/scip.pxi":652
+ *         return Variable.create(SCIPboundchgGetVar(self.scip_boundchg))
+ * 
+ *     def getBoundchgtype(self):             # <<<<<<<<<<<<<<
+ *         """Returns the bound change type of the bound change."""
+ *         return SCIPboundchgGetBoundchgtype(self.scip_boundchg)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_11BoundChange_5getBoundchgtype, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_BoundChange_getBoundchgtype, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__536)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 652, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_BoundChange, __pyx_n_s_getBoundchgtype, __pyx_t_2) < 0) __PYX_ERR(0, 652, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_BoundChange);
+
+  /* "src/pyscipopt/scip.pxi":656
+ *         return SCIPboundchgGetBoundchgtype(self.scip_boundchg)
+ * 
+ *     def getBoundtype(self):             # <<<<<<<<<<<<<<
+ *         """Returns the bound type of the bound change."""
+ *         return SCIPboundchgGetBoundtype(self.scip_boundchg)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_11BoundChange_7getBoundtype, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_BoundChange_getBoundtype, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__537)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 656, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_BoundChange, __pyx_n_s_getBoundtype, __pyx_t_2) < 0) __PYX_ERR(0, 656, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_BoundChange);
+
+  /* "src/pyscipopt/scip.pxi":660
+ *         return SCIPboundchgGetBoundtype(self.scip_boundchg)
+ * 
+ *     def isRedundant(self):             # <<<<<<<<<<<<<<
+ *         """Returns whether the bound change is redundant due to a more global bound that is at least as strong."""
+ *         return SCIPboundchgIsRedundant(self.scip_boundchg)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_11BoundChange_9isRedundant, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_BoundChange_isRedundant, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__538)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 660, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_BoundChange, __pyx_n_s_isRedundant, __pyx_t_2) < 0) __PYX_ERR(0, 660, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_BoundChange);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_11BoundChange_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_BoundChange___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__539)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_boundchg cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_11BoundChange_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_BoundChange___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__540)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":680
+ *         return domchg
+ * 
+ *     def getBoundchgs(self):             # <<<<<<<<<<<<<<
+ *         """Returns the bound changes in the domain change."""
+ *         nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_13DomainChanges_1getBoundchgs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_DomainChanges_getBoundchgs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__542)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 680, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_DomainChanges, __pyx_n_s_getBoundchgs, __pyx_t_2) < 0) __PYX_ERR(0, 680, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_DomainChanges);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_13DomainChanges_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_DomainChanges___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__543)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_domchg cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_13DomainChanges_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_DomainChanges___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__544)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":697
+ *         return node
+ * 
+ *     def getParent(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve parent node (or None if the node has no parent node)."""
+ *         return Node.create(SCIPnodeGetParent(self.scip_node))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_1getParent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getParent, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__545)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 697, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getParent, __pyx_t_2) < 0) __PYX_ERR(0, 697, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":701
+ *         return Node.create(SCIPnodeGetParent(self.scip_node))
+ * 
+ *     def getNumber(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve number of node."""
+ *         return SCIPnodeGetNumber(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_3getNumber, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getNumber, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__546)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 701, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getNumber, __pyx_t_2) < 0) __PYX_ERR(0, 701, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":705
+ *         return SCIPnodeGetNumber(self.scip_node)
+ * 
+ *     def getDepth(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve depth of node."""
+ *         return SCIPnodeGetDepth(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_5getDepth, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getDepth, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__547)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 705, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getDepth, __pyx_t_2) < 0) __PYX_ERR(0, 705, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":709
+ *         return SCIPnodeGetDepth(self.scip_node)
+ * 
+ *     def getType(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve type of node."""
+ *         return SCIPnodeGetType(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_7getType, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getType, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__548)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 709, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getType, __pyx_t_2) < 0) __PYX_ERR(0, 709, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":713
+ *         return SCIPnodeGetType(self.scip_node)
+ * 
+ *     def getLowerbound(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve lower bound of node."""
+ *         return SCIPnodeGetLowerbound(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_9getLowerbound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getLowerbound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__549)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 713, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getLowerbound, __pyx_t_2) < 0) __PYX_ERR(0, 713, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":717
+ *         return SCIPnodeGetLowerbound(self.scip_node)
+ * 
+ *     def getEstimate(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the estimated value of the best feasible solution in subtree of the node"""
+ *         return SCIPnodeGetEstimate(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_11getEstimate, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getEstimate, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__550)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 717, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getEstimate, __pyx_t_2) < 0) __PYX_ERR(0, 717, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":721
+ *         return SCIPnodeGetEstimate(self.scip_node)
+ * 
+ *     def getAddedConss(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve all constraints added at this node."""
+ *         cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_13getAddedConss, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getAddedConss, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__552)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 721, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getAddedConss, __pyx_t_2) < 0) __PYX_ERR(0, 721, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":734
+ *         return constraints
+ * 
+ *     def getNAddedConss(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve number of added constraints at this node"""
+ *         return SCIPnodeGetNAddedConss(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_15getNAddedConss, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getNAddedConss, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__553)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 734, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getNAddedConss, __pyx_t_2) < 0) __PYX_ERR(0, 734, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":738
+ *         return SCIPnodeGetNAddedConss(self.scip_node)
+ * 
+ *     def isActive(self):             # <<<<<<<<<<<<<<
+ *         """Is the node in the path to the current node?"""
+ *         return SCIPnodeIsActive(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_17isActive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_isActive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__554)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 738, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_isActive, __pyx_t_2) < 0) __PYX_ERR(0, 738, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":742
+ *         return SCIPnodeIsActive(self.scip_node)
+ * 
+ *     def isPropagatedAgain(self):             # <<<<<<<<<<<<<<
+ *         """Is the node marked to be propagated again?"""
+ *         return SCIPnodeIsPropagatedAgain(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_19isPropagatedAgain, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_isPropagatedAgain, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__555)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 742, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_isPropagatedAgain, __pyx_t_2) < 0) __PYX_ERR(0, 742, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":746
+ *         return SCIPnodeIsPropagatedAgain(self.scip_node)
+ * 
+ *     def getNParentBranchings(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the number of variable branchings that were performed in the parent node to create this node."""
+ *         cdef SCIP_VAR* dummy_branchvars
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_21getNParentBranchings, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getNParentBranchings, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__557)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 746, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getNParentBranchings, __pyx_t_2) < 0) __PYX_ERR(0, 746, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":760
+ *         return nbranchvars
+ * 
+ *     def getParentBranchings(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the set of variable branchings that were performed in the parent node to create this node."""
+ *         cdef int nbranchvars = self.getNParentBranchings()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_23getParentBranchings, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getParentBranchings, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__559)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 760, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getParentBranchings, __pyx_t_2) < 0) __PYX_ERR(0, 760, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":782
+ *         return py_variables, py_branchbounds, py_boundtypes
+ * 
+ *     def getNDomchg(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the number of bound changes due to branching, constraint propagation, and propagation."""
+ *         cdef int nbranchings
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_25getNDomchg, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getNDomchg, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__561)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 782, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getNDomchg, __pyx_t_2) < 0) __PYX_ERR(0, 782, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "src/pyscipopt/scip.pxi":790
+ *         return nbranchings, nconsprop, nprop
+ * 
+ *     def getDomchg(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve domain changes for this node."""
+ *         cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_27getDomchg, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node_getDomchg, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__563)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 790, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Node, __pyx_n_s_getDomchg, __pyx_t_2) < 0) __PYX_ERR(0, 790, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Node);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_node cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_33__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__564)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip_node cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_node cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_4Node_35__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Node___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__565)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":821
+ *             return cname.decode('utf-8')
+ * 
+ *     def ptr(self):             # <<<<<<<<<<<<<<
+ *         """ """
+ *         return (self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_1ptr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_ptr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__566)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 821, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_ptr, __pyx_t_2) < 0) __PYX_ERR(0, 821, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":828
+ *         return self.name
+ * 
+ *     def vtype(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)"""
+ *         vartype = SCIPvarGetType(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_5vtype, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_vtype, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__568)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 828, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_vtype, __pyx_t_2) < 0) __PYX_ERR(0, 828, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":840
+ *             return "IMPLINT"
+ * 
+ *     def isOriginal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve whether the variable belongs to the original problem"""
+ *         return SCIPvarIsOriginal(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_7isOriginal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_isOriginal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__569)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 840, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_isOriginal, __pyx_t_2) < 0) __PYX_ERR(0, 840, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":844
+ *         return SCIPvarIsOriginal(self.scip_var)
+ * 
+ *     def isInLP(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve whether the variable is a COLUMN variable that is member of the current LP"""
+ *         return SCIPvarIsInLP(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_9isInLP, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_isInLP, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__570)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 844, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_isInLP, __pyx_t_2) < 0) __PYX_ERR(0, 844, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":849
+ * 
+ * 
+ *     def getIndex(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the unique index of the variable."""
+ *         return SCIPvarGetIndex(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_11getIndex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getIndex, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__571)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 849, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getIndex, __pyx_t_2) < 0) __PYX_ERR(0, 849, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":853
+ *         return SCIPvarGetIndex(self.scip_var)
+ * 
+ *     def getCol(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve column of COLUMN variable"""
+ *         cdef SCIP_COL* scip_col
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_13getCol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getCol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__573)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 853, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getCol, __pyx_t_2) < 0) __PYX_ERR(0, 853, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":859
+ *         return Column.create(scip_col)
+ * 
+ *     def getLbOriginal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve original lower bound of variable"""
+ *         return SCIPvarGetLbOriginal(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_15getLbOriginal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getLbOriginal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__574)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 859, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getLbOriginal, __pyx_t_2) < 0) __PYX_ERR(0, 859, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":863
+ *         return SCIPvarGetLbOriginal(self.scip_var)
+ * 
+ *     def getUbOriginal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve original upper bound of variable"""
+ *         return SCIPvarGetUbOriginal(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_17getUbOriginal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getUbOriginal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__575)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 863, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getUbOriginal, __pyx_t_2) < 0) __PYX_ERR(0, 863, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":867
+ *         return SCIPvarGetUbOriginal(self.scip_var)
+ * 
+ *     def getLbGlobal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve global lower bound of variable"""
+ *         return SCIPvarGetLbGlobal(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_19getLbGlobal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getLbGlobal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__576)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 867, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getLbGlobal, __pyx_t_2) < 0) __PYX_ERR(0, 867, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":871
+ *         return SCIPvarGetLbGlobal(self.scip_var)
+ * 
+ *     def getUbGlobal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve global upper bound of variable"""
+ *         return SCIPvarGetUbGlobal(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_21getUbGlobal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getUbGlobal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__577)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 871, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getUbGlobal, __pyx_t_2) < 0) __PYX_ERR(0, 871, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":875
+ *         return SCIPvarGetUbGlobal(self.scip_var)
+ * 
+ *     def getLbLocal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve current lower bound of variable"""
+ *         return SCIPvarGetLbLocal(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_23getLbLocal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getLbLocal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__578)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 875, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getLbLocal, __pyx_t_2) < 0) __PYX_ERR(0, 875, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":879
+ *         return SCIPvarGetLbLocal(self.scip_var)
+ * 
+ *     def getUbLocal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve current upper bound of variable"""
+ *         return SCIPvarGetUbLocal(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_25getUbLocal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getUbLocal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__579)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 879, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getUbLocal, __pyx_t_2) < 0) __PYX_ERR(0, 879, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":883
+ *         return SCIPvarGetUbLocal(self.scip_var)
+ * 
+ *     def getObj(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve current objective value of variable"""
+ *         return SCIPvarGetObj(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_27getObj, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getObj, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__580)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 883, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getObj, __pyx_t_2) < 0) __PYX_ERR(0, 883, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "src/pyscipopt/scip.pxi":887
+ *         return SCIPvarGetObj(self.scip_var)
+ * 
+ *     def getLPSol(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the current LP solution value of variable"""
+ *         return SCIPvarGetLPSol(self.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_29getLPSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable_getLPSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__581)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 887, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Variable, __pyx_n_s_getLPSol, __pyx_t_2) < 0) __PYX_ERR(0, 887, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Variable);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_var cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_31__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__582)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip_var cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_var cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_8Variable_33__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Variable___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__583)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":910
+ *         return self.name
+ * 
+ *     def isOriginal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve whether the constraint belongs to the original problem"""
+ *         return SCIPconsIsOriginal(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_3isOriginal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isOriginal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__584)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 910, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isOriginal, __pyx_t_2) < 0) __PYX_ERR(0, 910, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":914
+ *         return SCIPconsIsOriginal(self.scip_cons)
+ * 
+ *     def isInitial(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if the relaxation of the constraint should be in the initial LP"""
+ *         return SCIPconsIsInitial(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_5isInitial, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isInitial, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__585)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 914, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isInitial, __pyx_t_2) < 0) __PYX_ERR(0, 914, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":918
+ *         return SCIPconsIsInitial(self.scip_cons)
+ * 
+ *     def isSeparated(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint should be separated during LP processing"""
+ *         return SCIPconsIsSeparated(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_7isSeparated, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isSeparated, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__586)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 918, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isSeparated, __pyx_t_2) < 0) __PYX_ERR(0, 918, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":922
+ *         return SCIPconsIsSeparated(self.scip_cons)
+ * 
+ *     def isEnforced(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint should be enforced during node processing"""
+ *         return SCIPconsIsEnforced(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_9isEnforced, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isEnforced, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__587)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 922, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isEnforced, __pyx_t_2) < 0) __PYX_ERR(0, 922, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":926
+ *         return SCIPconsIsEnforced(self.scip_cons)
+ * 
+ *     def isChecked(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint should be checked for feasibility"""
+ *         return SCIPconsIsChecked(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_11isChecked, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isChecked, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__588)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 926, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isChecked, __pyx_t_2) < 0) __PYX_ERR(0, 926, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":930
+ *         return SCIPconsIsChecked(self.scip_cons)
+ * 
+ *     def isPropagated(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint should be propagated during node processing"""
+ *         return SCIPconsIsPropagated(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_13isPropagated, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isPropagated, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__589)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 930, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isPropagated, __pyx_t_2) < 0) __PYX_ERR(0, 930, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":934
+ *         return SCIPconsIsPropagated(self.scip_cons)
+ * 
+ *     def isLocal(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint is only locally valid or not added to any (sub)problem"""
+ *         return SCIPconsIsLocal(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_15isLocal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isLocal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__590)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 934, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isLocal, __pyx_t_2) < 0) __PYX_ERR(0, 934, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":938
+ *         return SCIPconsIsLocal(self.scip_cons)
+ * 
+ *     def isModifiable(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint is modifiable (subject to column generation)"""
+ *         return SCIPconsIsModifiable(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_17isModifiable, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isModifiable, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__591)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 938, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isModifiable, __pyx_t_2) < 0) __PYX_ERR(0, 938, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":942
+ *         return SCIPconsIsModifiable(self.scip_cons)
+ * 
+ *     def isDynamic(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint is subject to aging"""
+ *         return SCIPconsIsDynamic(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_19isDynamic, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isDynamic, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__592)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 942, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isDynamic, __pyx_t_2) < 0) __PYX_ERR(0, 942, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":946
+ *         return SCIPconsIsDynamic(self.scip_cons)
+ * 
+ *     def isRemovable(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint's relaxation should be removed from the LP due to aging or cleanup"""
+ *         return SCIPconsIsRemovable(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_21isRemovable, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isRemovable, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__593)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 946, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isRemovable, __pyx_t_2) < 0) __PYX_ERR(0, 946, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":950
+ *         return SCIPconsIsRemovable(self.scip_cons)
+ * 
+ *     def isStickingAtNode(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint is only locally valid or not added to any (sub)problem"""
+ *         return SCIPconsIsStickingAtNode(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_23isStickingAtNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isStickingAtNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__594)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 950, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isStickingAtNode, __pyx_t_2) < 0) __PYX_ERR(0, 950, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":954
+ *         return SCIPconsIsStickingAtNode(self.scip_cons)
+ * 
+ *     def isActive(self):             # <<<<<<<<<<<<<<
+ *         """returns True iff constraint is active in the current node"""
+ *         return SCIPconsIsActive(self.scip_cons)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_25isActive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isActive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__595)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 954, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isActive, __pyx_t_2) < 0) __PYX_ERR(0, 954, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":958
+ *         return SCIPconsIsActive(self.scip_cons)
+ * 
+ *     def isLinear(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint is linear"""
+ *         constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8')
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_27isLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__597)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 958, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isLinear, __pyx_t_2) < 0) __PYX_ERR(0, 958, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":963
+ *         return constype == 'linear'
+ * 
+ *     def isNonlinear(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve True if constraint is nonlinear"""
+ *         constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8')
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_29isNonlinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_isNonlinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__598)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 963, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_isNonlinear, __pyx_t_2) < 0) __PYX_ERR(0, 963, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "src/pyscipopt/scip.pxi":968
+ *         return constype == 'nonlinear'
+ * 
+ *     def getConshdlrName(self):             # <<<<<<<<<<<<<<
+ *         """Return the constraint handler's name"""
+ *         constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8')
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_31getConshdlrName, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint_getConshdlrName, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__599)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 968, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Constraint, __pyx_n_s_getConshdlrName, __pyx_t_2) < 0) __PYX_ERR(0, 968, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Constraint);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_37__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__600)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self.scip_cons cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_10Constraint_39__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Constraint___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__601)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":1073
+ *         self._freescip = val
+ * 
+ *     @cython.always_allow_keywords(True)             # <<<<<<<<<<<<<<
+ *     @staticmethod
+ *     def from_ptr(capsule, take_ownership):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_9from_ptr, __Pyx_CYFUNCTION_STATICMETHOD | __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_from_ptr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__603)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1073, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_from_ptr, __pyx_t_2) < 0) __PYX_ERR(0, 1073, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1074
+ * 
+ *     @cython.always_allow_keywords(True)
+ *     @staticmethod             # <<<<<<<<<<<<<<
+ *     def from_ptr(capsule, take_ownership):
+ *         """Create a Model from a given pointer.
+ */
+  __Pyx_GetNameInClass(__pyx_t_2, (PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_from_ptr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1073, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_staticmethod, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1074, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_from_ptr, __pyx_t_3) < 0) __PYX_ERR(0, 1073, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1088
+ *         return model
+ * 
+ *     @cython.always_allow_keywords(True)             # <<<<<<<<<<<<<<
+ *     def to_ptr(self, give_ownership):
+ *         """Return the underlying Scip pointer to the current Model.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_11to_ptr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_to_ptr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__605)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1088, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_to_ptr, __pyx_t_3) < 0) __PYX_ERR(0, 1088, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1102
+ *         return capsule
+ * 
+ *     def includeDefaultPlugins(self):             # <<<<<<<<<<<<<<
+ *         """Includes all default plug-ins into SCIP"""
+ *         PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_13includeDefaultPlugins, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeDefaultPlugins, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__606)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1102, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeDefaultPlugins, __pyx_t_3) < 0) __PYX_ERR(0, 1102, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1106
+ *         PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip))
+ * 
+ *     def createProbBasic(self, problemName='model'):             # <<<<<<<<<<<<<<
+ *         """Create new problem instance with given name
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_15createProbBasic, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createProbBasic, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__608)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__609);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createProbBasic, __pyx_t_3) < 0) __PYX_ERR(0, 1106, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1115
+ *         PY_SCIP_CALL(SCIPcreateProbBasic(self._scip, n))
+ * 
+ *     def freeProb(self):             # <<<<<<<<<<<<<<
+ *         """Frees problem and solution process data"""
+ *         PY_SCIP_CALL(SCIPfreeProb(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_17freeProb, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_freeProb, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__610)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1115, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_freeProb, __pyx_t_3) < 0) __PYX_ERR(0, 1115, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1119
+ *         PY_SCIP_CALL(SCIPfreeProb(self._scip))
+ * 
+ *     def freeTransform(self):             # <<<<<<<<<<<<<<
+ *         """Frees all solution process data including presolving and transformed problem, only original problem is kept"""
+ *         self._modelvars = {
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_19freeTransform, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_freeTransform, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__612)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1119, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_freeTransform, __pyx_t_3) < 0) __PYX_ERR(0, 1119, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1128
+ *         PY_SCIP_CALL(SCIPfreeTransform(self._scip))
+ * 
+ *     def version(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve SCIP version"""
+ *         return SCIPversion()
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_21version, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_version, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__613)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_version, __pyx_t_3) < 0) __PYX_ERR(0, 1128, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1132
+ *         return SCIPversion()
+ * 
+ *     def printVersion(self):             # <<<<<<<<<<<<<<
+ *         """Print version, copyright information and compile mode"""
+ *         user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_23printVersion, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_printVersion, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__615)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_printVersion, __pyx_t_3) < 0) __PYX_ERR(0, 1132, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1141
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def printExternalCodeVersions(self):             # <<<<<<<<<<<<<<
+ *         """Print external code versions, e.g. symmetry, non-linear solver, lp solver"""
+ *         user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_25printExternalCodeVersions, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_printExternalCodeVersions, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__616)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_printExternalCodeVersions, __pyx_t_3) < 0) __PYX_ERR(0, 1141, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1150
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def getProbName(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve problem name"""
+ *         return bytes(SCIPgetProbName(self._scip)).decode('UTF-8')
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_27getProbName, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getProbName, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__617)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getProbName, __pyx_t_3) < 0) __PYX_ERR(0, 1150, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1154
+ *         return bytes(SCIPgetProbName(self._scip)).decode('UTF-8')
+ * 
+ *     def getTotalTime(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the current total SCIP time in seconds, i.e. the total time since the SCIP instance has been created"""
+ *         return SCIPgetTotalTime(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_29getTotalTime, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getTotalTime, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__618)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1154, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getTotalTime, __pyx_t_3) < 0) __PYX_ERR(0, 1154, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1158
+ *         return SCIPgetTotalTime(self._scip)
+ * 
+ *     def getSolvingTime(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the current solving time in seconds"""
+ *         return SCIPgetSolvingTime(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_31getSolvingTime, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getSolvingTime, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__619)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1158, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getSolvingTime, __pyx_t_3) < 0) __PYX_ERR(0, 1158, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1162
+ *         return SCIPgetSolvingTime(self._scip)
+ * 
+ *     def getReadingTime(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the current reading time in seconds"""
+ *         return SCIPgetReadingTime(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_33getReadingTime, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getReadingTime, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__620)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1162, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getReadingTime, __pyx_t_3) < 0) __PYX_ERR(0, 1162, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1166
+ *         return SCIPgetReadingTime(self._scip)
+ * 
+ *     def getPresolvingTime(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the curernt presolving time in seconds"""
+ *         return SCIPgetPresolvingTime(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_35getPresolvingTime, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getPresolvingTime, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__621)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getPresolvingTime, __pyx_t_3) < 0) __PYX_ERR(0, 1166, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1170
+ *         return SCIPgetPresolvingTime(self._scip)
+ * 
+ *     def getNLPIterations(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the total number of LP iterations so far."""
+ *         return SCIPgetNLPIterations(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_37getNLPIterations, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNLPIterations, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__622)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNLPIterations, __pyx_t_3) < 0) __PYX_ERR(0, 1170, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1174
+ *         return SCIPgetNLPIterations(self._scip)
+ * 
+ *     def getNNodes(self):             # <<<<<<<<<<<<<<
+ *         """gets number of processed nodes in current run, including the focus node."""
+ *         return SCIPgetNNodes(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_39getNNodes, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNNodes, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__623)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNNodes, __pyx_t_3) < 0) __PYX_ERR(0, 1174, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1178
+ *         return SCIPgetNNodes(self._scip)
+ * 
+ *     def getNTotalNodes(self):             # <<<<<<<<<<<<<<
+ *         """gets number of processed nodes in all runs, including the focus node."""
+ *         return SCIPgetNTotalNodes(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_41getNTotalNodes, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNTotalNodes, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__624)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1178, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNTotalNodes, __pyx_t_3) < 0) __PYX_ERR(0, 1178, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1182
+ *         return SCIPgetNTotalNodes(self._scip)
+ * 
+ *     def getNFeasibleLeaves(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve number of leaf nodes processed with feasible relaxation solution."""
+ *         return SCIPgetNFeasibleLeaves(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_43getNFeasibleLeaves, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNFeasibleLeaves, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__625)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNFeasibleLeaves, __pyx_t_3) < 0) __PYX_ERR(0, 1182, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1186
+ *         return SCIPgetNFeasibleLeaves(self._scip)
+ * 
+ *     def getNInfeasibleLeaves(self):             # <<<<<<<<<<<<<<
+ *         """gets number of infeasible leaf nodes processed."""
+ *         return SCIPgetNInfeasibleLeaves(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_45getNInfeasibleLeaves, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNInfeasibleLeaves, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__626)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNInfeasibleLeaves, __pyx_t_3) < 0) __PYX_ERR(0, 1186, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1190
+ *         return SCIPgetNInfeasibleLeaves(self._scip)
+ * 
+ *     def getNLeaves(self):             # <<<<<<<<<<<<<<
+ *         """gets number of leaves in the tree."""
+ *         return SCIPgetNLeaves(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_47getNLeaves, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNLeaves, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__627)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNLeaves, __pyx_t_3) < 0) __PYX_ERR(0, 1190, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1194
+ *         return SCIPgetNLeaves(self._scip)
+ * 
+ *     def getNChildren(self):             # <<<<<<<<<<<<<<
+ *         """gets number of children of focus node."""
+ *         return SCIPgetNChildren(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_49getNChildren, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNChildren, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__628)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1194, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNChildren, __pyx_t_3) < 0) __PYX_ERR(0, 1194, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1198
+ *         return SCIPgetNChildren(self._scip)
+ * 
+ *     def getNSiblings(self):             # <<<<<<<<<<<<<<
+ *         """gets number of siblings of focus node."""
+ *         return SCIPgetNSiblings(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_51getNSiblings, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNSiblings, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__629)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1198, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNSiblings, __pyx_t_3) < 0) __PYX_ERR(0, 1198, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1202
+ *         return SCIPgetNSiblings(self._scip)
+ * 
+ *     def getCurrentNode(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve current node."""
+ *         return Node.create(SCIPgetCurrentNode(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_53getCurrentNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getCurrentNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__630)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1202, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getCurrentNode, __pyx_t_3) < 0) __PYX_ERR(0, 1202, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1206
+ *         return Node.create(SCIPgetCurrentNode(self._scip))
+ * 
+ *     def getGap(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the gap, i.e. |(primalbound - dualbound)/min(|primalbound|,|dualbound|)|."""
+ *         return SCIPgetGap(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_55getGap, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getGap, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__631)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getGap, __pyx_t_3) < 0) __PYX_ERR(0, 1206, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1210
+ *         return SCIPgetGap(self._scip)
+ * 
+ *     def getDepth(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the depth of the current node"""
+ *         return SCIPgetDepth(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_57getDepth, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getDepth, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__632)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getDepth, __pyx_t_3) < 0) __PYX_ERR(0, 1210, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1214
+ *         return SCIPgetDepth(self._scip)
+ * 
+ *     def infinity(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve SCIP's infinity value"""
+ *         return SCIPinfinity(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_59infinity, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_infinity, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__633)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1214, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_infinity, __pyx_t_3) < 0) __PYX_ERR(0, 1214, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1218
+ *         return SCIPinfinity(self._scip)
+ * 
+ *     def epsilon(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve epsilon for e.g. equality checks"""
+ *         return SCIPepsilon(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_61epsilon, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_epsilon, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__634)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_epsilon, __pyx_t_3) < 0) __PYX_ERR(0, 1218, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1222
+ *         return SCIPepsilon(self._scip)
+ * 
+ *     def feastol(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve feasibility tolerance"""
+ *         return SCIPfeastol(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_63feastol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_feastol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__635)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_feastol, __pyx_t_3) < 0) __PYX_ERR(0, 1222, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1226
+ *         return SCIPfeastol(self._scip)
+ * 
+ *     def feasFrac(self, value):             # <<<<<<<<<<<<<<
+ *         """returns fractional part of value, i.e. x - floor(x) in feasible tolerance: x - floor(x+feastol)"""
+ *         return SCIPfeasFrac(self._scip, value)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_65feasFrac, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_feasFrac, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__637)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1226, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_feasFrac, __pyx_t_3) < 0) __PYX_ERR(0, 1226, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1230
+ *         return SCIPfeasFrac(self._scip, value)
+ * 
+ *     def frac(self, value):             # <<<<<<<<<<<<<<
+ *         """returns fractional part of value, i.e. x - floor(x) in epsilon tolerance: x - floor(x+eps)"""
+ *         return SCIPfrac(self._scip, value)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_67frac, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_frac, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__638)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_frac, __pyx_t_3) < 0) __PYX_ERR(0, 1230, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1234
+ *         return SCIPfrac(self._scip, value)
+ * 
+ *     def isZero(self, value):             # <<<<<<<<<<<<<<
+ *         """returns whether abs(value) < eps"""
+ *         return SCIPisZero(self._scip, value)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_69isZero, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isZero, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__639)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1234, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isZero, __pyx_t_3) < 0) __PYX_ERR(0, 1234, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1238
+ *         return SCIPisZero(self._scip, value)
+ * 
+ *     def isFeasZero(self, value):             # <<<<<<<<<<<<<<
+ *         """returns whether abs(value) < feastol"""
+ *         return SCIPisFeasZero(self._scip, value)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_71isFeasZero, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isFeasZero, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__640)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isFeasZero, __pyx_t_3) < 0) __PYX_ERR(0, 1238, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1242
+ *         return SCIPisFeasZero(self._scip, value)
+ * 
+ *     def isInfinity(self, value):             # <<<<<<<<<<<<<<
+ *         """returns whether value is SCIP's infinity"""
+ *         return SCIPisInfinity(self._scip, value)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_73isInfinity, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isInfinity, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__641)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isInfinity, __pyx_t_3) < 0) __PYX_ERR(0, 1242, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1246
+ *         return SCIPisInfinity(self._scip, value)
+ * 
+ *     def isFeasNegative(self, value):             # <<<<<<<<<<<<<<
+ *         """returns whether value < -feastol"""
+ *         return SCIPisFeasNegative(self._scip, value)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_75isFeasNegative, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isFeasNegative, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__642)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isFeasNegative, __pyx_t_3) < 0) __PYX_ERR(0, 1246, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1250
+ *         return SCIPisFeasNegative(self._scip, value)
+ * 
+ *     def isFeasIntegral(self, value):             # <<<<<<<<<<<<<<
+ *         """returns whether value is integral within the LP feasibility bounds"""
+ *         return SCIPisFeasIntegral(self._scip, value)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_77isFeasIntegral, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isFeasIntegral, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__643)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1250, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isFeasIntegral, __pyx_t_3) < 0) __PYX_ERR(0, 1250, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1254
+ *         return SCIPisFeasIntegral(self._scip, value)
+ * 
+ *     def isEQ(self, val1, val2):             # <<<<<<<<<<<<<<
+ *         """checks, if values are in range of epsilon"""
+ *         return SCIPisEQ(self._scip, val1, val2)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_79isEQ, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isEQ, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__645)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isEQ, __pyx_t_3) < 0) __PYX_ERR(0, 1254, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1258
+ *         return SCIPisEQ(self._scip, val1, val2)
+ * 
+ *     def isFeasEQ(self, val1, val2):             # <<<<<<<<<<<<<<
+ *         """checks, if relative difference of values is in range of feasibility tolerance"""
+ *         return SCIPisFeasEQ(self._scip, val1, val2)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_81isFeasEQ, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isFeasEQ, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__646)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1258, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isFeasEQ, __pyx_t_3) < 0) __PYX_ERR(0, 1258, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1262
+ *         return SCIPisFeasEQ(self._scip, val1, val2)
+ * 
+ *     def isLE(self, val1, val2):             # <<<<<<<<<<<<<<
+ *         """returns whether val1 <= val2 + eps"""
+ *         return SCIPisLE(self._scip, val1, val2)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_83isLE, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isLE, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__647)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1262, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isLE, __pyx_t_3) < 0) __PYX_ERR(0, 1262, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1266
+ *         return SCIPisLE(self._scip, val1, val2)
+ * 
+ *     def isLT(self, val1, val2):             # <<<<<<<<<<<<<<
+ *         """returns whether val1 < val2 - eps"""
+ *         return SCIPisLT(self._scip, val1, val2)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_85isLT, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isLT, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__648)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isLT, __pyx_t_3) < 0) __PYX_ERR(0, 1266, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1270
+ *         return SCIPisLT(self._scip, val1, val2)
+ * 
+ *     def isGE(self, val1, val2):             # <<<<<<<<<<<<<<
+ *         """returns whether val1 >= val2 - eps"""
+ *         return SCIPisGE(self._scip, val1, val2)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_87isGE, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isGE, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__649)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isGE, __pyx_t_3) < 0) __PYX_ERR(0, 1270, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1274
+ *         return SCIPisGE(self._scip, val1, val2)
+ * 
+ *     def isGT(self, val1, val2):             # <<<<<<<<<<<<<<
+ *         """returns whether val1 > val2 + eps"""
+ *         return SCIPisGT(self._scip, val1, val2)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_89isGT, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isGT, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__650)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isGT, __pyx_t_3) < 0) __PYX_ERR(0, 1274, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1278
+ *         return SCIPisGT(self._scip, val1, val2)
+ * 
+ *     def getCondition(self, exact=False):             # <<<<<<<<<<<<<<
+ *         """Get the current LP's condition number
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_91getCondition, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getCondition, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__652)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1278, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getCondition, __pyx_t_3) < 0) __PYX_ERR(0, 1278, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1294
+ *         return quality
+ * 
+ *     def enableReoptimization(self, enable=True):             # <<<<<<<<<<<<<<
+ *         """include specific heuristics and branching rules for reoptimization"""
+ *         PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_93enableReoptimization, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_enableReoptimization, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__655)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_enableReoptimization, __pyx_t_3) < 0) __PYX_ERR(0, 1294, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1298
+ *         PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable))
+ * 
+ *     def lpiGetIterations(self):             # <<<<<<<<<<<<<<
+ *         """Get the iteration count of the last solved LP"""
+ *         cdef SCIP_LPI* lpi
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_95lpiGetIterations, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_lpiGetIterations, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__657)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1298, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_lpiGetIterations, __pyx_t_3) < 0) __PYX_ERR(0, 1298, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1308
+ *     # Objective function
+ * 
+ *     def setMinimize(self):             # <<<<<<<<<<<<<<
+ *         """Set the objective sense to minimization."""
+ *         PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_97setMinimize, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setMinimize, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__658)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1308, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setMinimize, __pyx_t_3) < 0) __PYX_ERR(0, 1308, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1312
+ *         PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE))
+ * 
+ *     def setMaximize(self):             # <<<<<<<<<<<<<<
+ *         """Set the objective sense to maximization."""
+ *         PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_99setMaximize, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setMaximize, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__659)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1312, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setMaximize, __pyx_t_3) < 0) __PYX_ERR(0, 1312, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1316
+ *         PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE))
+ * 
+ *     def setObjlimit(self, objlimit):             # <<<<<<<<<<<<<<
+ *         """Set a limit on the objective function.
+ *         Only solutions with objective value better than this limit are accepted.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_101setObjlimit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setObjlimit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__661)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1316, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setObjlimit, __pyx_t_3) < 0) __PYX_ERR(0, 1316, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1325
+ *         PY_SCIP_CALL(SCIPsetObjlimit(self._scip, objlimit))
+ * 
+ *     def getObjlimit(self):             # <<<<<<<<<<<<<<
+ *         """returns current limit on objective function."""
+ *         return SCIPgetObjlimit(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_103getObjlimit, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getObjlimit, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__662)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1325, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getObjlimit, __pyx_t_3) < 0) __PYX_ERR(0, 1325, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1329
+ *         return SCIPgetObjlimit(self._scip)
+ * 
+ *     def setObjective(self, expr, sense = 'minimize', clear = 'true'):             # <<<<<<<<<<<<<<
+ *         """Establish the objective function as a linear expression.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_105setObjective, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setObjective, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__664)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1329, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__665);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setObjective, __pyx_t_3) < 0) __PYX_ERR(0, 1329, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1374
+ *             raise Warning("unrecognized optimization sense: %s" % sense)
+ * 
+ *     def getObjective(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve objective function as Expr"""
+ *         variables = self.getVars()
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_107getObjective, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getObjective, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__667)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getObjective, __pyx_t_3) < 0) __PYX_ERR(0, 1374, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1385
+ *         return objective
+ * 
+ *     def addObjoffset(self, offset, solutions = False):             # <<<<<<<<<<<<<<
+ *         """Add constant offset to objective
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_109addObjoffset, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addObjoffset, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__669)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1385, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addObjoffset, __pyx_t_3) < 0) __PYX_ERR(0, 1385, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1397
+ *             PY_SCIP_CALL(SCIPaddOrigObjoffset(self._scip, offset))
+ * 
+ *     def getObjoffset(self, original = True):             # <<<<<<<<<<<<<<
+ *         """Retrieve constant objective offset
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_111getObjoffset, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getObjoffset, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__671)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1397, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getObjoffset, __pyx_t_3) < 0) __PYX_ERR(0, 1397, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1408
+ *             return SCIPgetTransObjoffset(self._scip)
+ * 
+ *     def setObjIntegral(self):             # <<<<<<<<<<<<<<
+ *         """informs SCIP that the objective value is always integral in every feasible solution
+ *         Note: This function should be used to inform SCIP that the objective function is integral, helping to improve the
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_113setObjIntegral, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setObjIntegral, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__672)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1408, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setObjIntegral, __pyx_t_3) < 0) __PYX_ERR(0, 1408, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1418
+ *         PY_SCIP_CALL(SCIPsetObjIntegral(self._scip))
+ * 
+ *     def getLocalEstimate(self, original = False):             # <<<<<<<<<<<<<<
+ *         """gets estimate of best primal solution w.r.t. original or transformed problem contained in current subtree
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_115getLocalEstimate, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLocalEstimate, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__673)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1418, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLocalEstimate, __pyx_t_3) < 0) __PYX_ERR(0, 1418, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1429
+ * 
+ *     # Setting parameters
+ *     def setPresolve(self, setting):             # <<<<<<<<<<<<<<
+ *         """Set presolving parameter settings.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_117setPresolve, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setPresolve, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__675)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1429, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setPresolve, __pyx_t_3) < 0) __PYX_ERR(0, 1429, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1437
+ *         PY_SCIP_CALL(SCIPsetPresolving(self._scip, setting, True))
+ * 
+ *     def setProbName(self, name):             # <<<<<<<<<<<<<<
+ *         """Set problem name"""
+ *         n = str_conversion(name)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_119setProbName, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setProbName, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__677)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1437, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setProbName, __pyx_t_3) < 0) __PYX_ERR(0, 1437, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1442
+ *         PY_SCIP_CALL(SCIPsetProbName(self._scip, n))
+ * 
+ *     def setSeparating(self, setting):             # <<<<<<<<<<<<<<
+ *         """Set separating parameter settings.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_121setSeparating, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setSeparating, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__678)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1442, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setSeparating, __pyx_t_3) < 0) __PYX_ERR(0, 1442, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1450
+ *         PY_SCIP_CALL(SCIPsetSeparating(self._scip, setting, True))
+ * 
+ *     def setHeuristics(self, setting):             # <<<<<<<<<<<<<<
+ *         """Set heuristics parameter settings.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_123setHeuristics, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setHeuristics, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__679)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1450, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setHeuristics, __pyx_t_3) < 0) __PYX_ERR(0, 1450, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1458
+ *         PY_SCIP_CALL(SCIPsetHeuristics(self._scip, setting, True))
+ * 
+ *     def disablePropagation(self, onlyroot=False):             # <<<<<<<<<<<<<<
+ *         """Disables propagation in SCIP to avoid modifying the original problem during transformation.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_125disablePropagation, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_disablePropagation, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__681)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1458, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_disablePropagation, __pyx_t_3) < 0) __PYX_ERR(0, 1458, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1468
+ *             self.setIntParam("propagating/maxrounds", 0)
+ * 
+ *     def writeProblem(self, filename='model.cip', trans=False, genericnames=False, verbose=True):             # <<<<<<<<<<<<<<
+ *         """Write current model/problem to a file.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_127writeProblem, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeProblem, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__683)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1468, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__684);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeProblem, __pyx_t_3) < 0) __PYX_ERR(0, 1468, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1500
+ *     # Variable Functions
+ * 
+ *     def addVar(self, name='', vtype='C', lb=0.0, ub=None, obj=0.0, pricedVar=False, pricedVarScore=1.0):             # <<<<<<<<<<<<<<
+ *         """Create a new variable. Default variable is non-negative and continuous.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_129addVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__686)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1500, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__687);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addVar, __pyx_t_3) < 0) __PYX_ERR(0, 1500, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1558
+ *         return pyVar
+ * 
+ *     def getTransformedVar(self, Variable var):             # <<<<<<<<<<<<<<
+ *         """Retrieve the transformed variable.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_131getTransformedVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getTransformedVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__689)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1558, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getTransformedVar, __pyx_t_3) < 0) __PYX_ERR(0, 1558, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1569
+ *         return Variable.create(_tvar)
+ * 
+ *     def addVarLocks(self, Variable var, nlocksdown, nlocksup):             # <<<<<<<<<<<<<<
+ *         """adds given values to lock numbers of variable for rounding
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_133addVarLocks, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addVarLocks, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__691)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1569, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addVarLocks, __pyx_t_3) < 0) __PYX_ERR(0, 1569, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1579
+ *         PY_SCIP_CALL(SCIPaddVarLocks(self._scip, var.scip_var, nlocksdown, nlocksup))
+ * 
+ *     def fixVar(self, Variable var, val):             # <<<<<<<<<<<<<<
+ *         """Fixes the variable var to the value val if possible.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_135fixVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_fixVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__693)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1579, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_fixVar, __pyx_t_3) < 0) __PYX_ERR(0, 1579, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1592
+ *         return infeasible, fixed
+ * 
+ *     def delVar(self, Variable var):             # <<<<<<<<<<<<<<
+ *         """Delete a variable.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_137delVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_delVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__695)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1592, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_delVar, __pyx_t_3) < 0) __PYX_ERR(0, 1592, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1605
+ *         return deleted
+ * 
+ *     def tightenVarLb(self, Variable var, lb, force=False):             # <<<<<<<<<<<<<<
+ *         """Tighten the lower bound in preprocessing or current node, if the bound is tighter.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_139tightenVarLb, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_tightenVarLb, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__697)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1605, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_tightenVarLb, __pyx_t_3) < 0) __PYX_ERR(0, 1605, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1621
+ *         return infeasible, tightened
+ * 
+ *     def tightenVarUb(self, Variable var, ub, force=False):             # <<<<<<<<<<<<<<
+ *         """Tighten the upper bound in preprocessing or current node, if the bound is tighter.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_141tightenVarUb, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_tightenVarUb, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__699)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1621, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_tightenVarUb, __pyx_t_3) < 0) __PYX_ERR(0, 1621, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1637
+ *         return infeasible, tightened
+ * 
+ *     def tightenVarUbGlobal(self, Variable var, ub, force=False):             # <<<<<<<<<<<<<<
+ *         """Tighten the global upper bound, if the bound is tighter.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_143tightenVarUbGlobal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_tightenVarUbGlobal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__700)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1637, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_tightenVarUbGlobal, __pyx_t_3) < 0) __PYX_ERR(0, 1637, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1653
+ *         return infeasible, tightened
+ * 
+ *     def tightenVarLbGlobal(self, Variable var, lb, force=False):             # <<<<<<<<<<<<<<
+ *         """Tighten the global upper bound, if the bound is tighter.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_145tightenVarLbGlobal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_tightenVarLbGlobal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__701)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1653, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_tightenVarLbGlobal, __pyx_t_3) < 0) __PYX_ERR(0, 1653, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1669
+ *         return infeasible, tightened
+ * 
+ *     def chgVarLb(self, Variable var, lb):             # <<<<<<<<<<<<<<
+ *         """Changes the lower bound of the specified variable.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_147chgVarLb, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarLb, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__703)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1669, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarLb, __pyx_t_3) < 0) __PYX_ERR(0, 1669, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1680
+ *         PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb))
+ * 
+ *     def chgVarUb(self, Variable var, ub):             # <<<<<<<<<<<<<<
+ *         """Changes the upper bound of the specified variable.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_149chgVarUb, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarUb, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__705)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1680, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarUb, __pyx_t_3) < 0) __PYX_ERR(0, 1680, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1691
+ *         PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub))
+ * 
+ *     def chgVarLbGlobal(self, Variable var, lb):             # <<<<<<<<<<<<<<
+ *         """Changes the global lower bound of the specified variable.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_151chgVarLbGlobal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarLbGlobal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__706)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1691, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarLbGlobal, __pyx_t_3) < 0) __PYX_ERR(0, 1691, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1702
+ *         PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb))
+ * 
+ *     def chgVarUbGlobal(self, Variable var, ub):             # <<<<<<<<<<<<<<
+ *         """Changes the global upper bound of the specified variable.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_153chgVarUbGlobal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarUbGlobal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__707)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarUbGlobal, __pyx_t_3) < 0) __PYX_ERR(0, 1702, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1713
+ *         PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub))
+ * 
+ *     def chgVarLbNode(self, Node node, Variable var, lb):             # <<<<<<<<<<<<<<
+ *         """Changes the lower bound of the specified variable at the given node.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_155chgVarLbNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarLbNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__709)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1713, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarLbNode, __pyx_t_3) < 0) __PYX_ERR(0, 1713, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1724
+ *         PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb))
+ * 
+ *     def chgVarUbNode(self, Node node, Variable var, ub):             # <<<<<<<<<<<<<<
+ *         """Changes the upper bound of the specified variable at the given node.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_157chgVarUbNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarUbNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__711)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1724, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarUbNode, __pyx_t_3) < 0) __PYX_ERR(0, 1724, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1735
+ *         PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub))
+ * 
+ *     def chgVarType(self, Variable var, vtype):             # <<<<<<<<<<<<<<
+ *         """Changes the type of a variable
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_159chgVarType, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarType, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__713)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1735, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarType, __pyx_t_3) < 0) __PYX_ERR(0, 1735, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1756
+ *             print('could not change variable type of variable %s' % var)
+ * 
+ *     def getVars(self, transformed=False):             # <<<<<<<<<<<<<<
+ *         """Retrieve all variables.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_161getVars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getVars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__715)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1756, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getVars, __pyx_t_3) < 0) __PYX_ERR(0, 1756, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1789
+ *         return vars
+ * 
+ *     def getNVars(self, transformed=True):             # <<<<<<<<<<<<<<
+ *         """Retrieve number of variables in the problems.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_163getNVars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNVars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__717)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1789, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNVars, __pyx_t_3) < 0) __PYX_ERR(0, 1789, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1799
+ *             return SCIPgetNOrigVars(self._scip)
+ * 
+ *     def getNIntVars(self):             # <<<<<<<<<<<<<<
+ *         """gets number of integer active problem variables"""
+ *         return SCIPgetNIntVars(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_165getNIntVars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNIntVars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__718)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1799, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNIntVars, __pyx_t_3) < 0) __PYX_ERR(0, 1799, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1803
+ *         return SCIPgetNIntVars(self._scip)
+ * 
+ *     def getNBinVars(self):             # <<<<<<<<<<<<<<
+ *         """gets number of binary active problem variables"""
+ *         return SCIPgetNBinVars(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_167getNBinVars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNBinVars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__719)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1803, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNBinVars, __pyx_t_3) < 0) __PYX_ERR(0, 1803, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1807
+ *         return SCIPgetNBinVars(self._scip)
+ * 
+ *     def getVarDict(self):             # <<<<<<<<<<<<<<
+ *         """gets dictionary with variables names as keys and current variable values as items"""
+ *         var_dict = {}
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_169getVarDict, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getVarDict, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__721)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1807, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getVarDict, __pyx_t_3) < 0) __PYX_ERR(0, 1807, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1814
+ *         return var_dict
+ * 
+ *     def updateNodeLowerbound(self, Node node, lb):             # <<<<<<<<<<<<<<
+ *         """if given value is larger than the node's lower bound (in transformed problem),
+ *         sets the node's lower bound to the new value
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_171updateNodeLowerbound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_updateNodeLowerbound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__723)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1814, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_updateNodeLowerbound, __pyx_t_3) < 0) __PYX_ERR(0, 1814, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1824
+ *         PY_SCIP_CALL(SCIPupdateNodeLowerbound(self._scip, node.scip_node, lb))
+ * 
+ *     def relax(self):             # <<<<<<<<<<<<<<
+ *         """Relaxes the integrality restrictions of the model"""
+ *         if self.getStage() != SCIP_STAGE_PROBLEM:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_173relax, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_relax, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__724)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1824, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_relax, __pyx_t_3) < 0) __PYX_ERR(0, 1824, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1833
+ * 
+ *     # Node methods
+ *     def getBestChild(self):             # <<<<<<<<<<<<<<
+ *         """gets the best child of the focus node w.r.t. the node selection strategy."""
+ *         return Node.create(SCIPgetBestChild(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_175getBestChild, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBestChild, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__725)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1833, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBestChild, __pyx_t_3) < 0) __PYX_ERR(0, 1833, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1837
+ *         return Node.create(SCIPgetBestChild(self._scip))
+ * 
+ *     def getBestSibling(self):             # <<<<<<<<<<<<<<
+ *         """gets the best sibling of the focus node w.r.t. the node selection strategy."""
+ *         return Node.create(SCIPgetBestSibling(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_177getBestSibling, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBestSibling, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__726)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1837, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBestSibling, __pyx_t_3) < 0) __PYX_ERR(0, 1837, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1841
+ *         return Node.create(SCIPgetBestSibling(self._scip))
+ * 
+ *     def getBestLeaf(self):             # <<<<<<<<<<<<<<
+ *         """gets the best leaf from the node queue w.r.t. the node selection strategy."""
+ *         return Node.create(SCIPgetBestLeaf(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_179getBestLeaf, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBestLeaf, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__727)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1841, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBestLeaf, __pyx_t_3) < 0) __PYX_ERR(0, 1841, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1845
+ *         return Node.create(SCIPgetBestLeaf(self._scip))
+ * 
+ *     def getBestNode(self):             # <<<<<<<<<<<<<<
+ *         """gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy."""
+ *         return Node.create(SCIPgetBestNode(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_181getBestNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBestNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__728)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1845, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBestNode, __pyx_t_3) < 0) __PYX_ERR(0, 1845, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1849
+ *         return Node.create(SCIPgetBestNode(self._scip))
+ * 
+ *     def getBestboundNode(self):             # <<<<<<<<<<<<<<
+ *         """gets the node with smallest lower bound from the tree (child, sibling, or leaf)."""
+ *         return Node.create(SCIPgetBestboundNode(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_183getBestboundNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBestboundNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__729)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1849, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBestboundNode, __pyx_t_3) < 0) __PYX_ERR(0, 1849, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1853
+ *         return Node.create(SCIPgetBestboundNode(self._scip))
+ * 
+ *     def getOpenNodes(self):             # <<<<<<<<<<<<<<
+ *         """access to all data of open nodes (leaves, children, and siblings)
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_185getOpenNodes, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getOpenNodes, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__731)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1853, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getOpenNodes, __pyx_t_3) < 0) __PYX_ERR(0, 1853, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1873
+ *         return leaves, children, siblings
+ * 
+ *     def repropagateNode(self, Node node):             # <<<<<<<<<<<<<<
+ *         """marks the given node to be propagated again the next time a node of its subtree is processed"""
+ *         PY_SCIP_CALL(SCIPrepropagateNode(self._scip, node.scip_node))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_187repropagateNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_repropagateNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__732)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1873, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_repropagateNode, __pyx_t_3) < 0) __PYX_ERR(0, 1873, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1879
+ * 
+ *     # LP Methods
+ *     def getLPSolstat(self):             # <<<<<<<<<<<<<<
+ *         """Gets solution status of current LP"""
+ *         return SCIPgetLPSolstat(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_189getLPSolstat, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLPSolstat, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__733)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1879, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLPSolstat, __pyx_t_3) < 0) __PYX_ERR(0, 1879, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1884
+ * 
+ * 
+ *     def constructLP(self):             # <<<<<<<<<<<<<<
+ *         """makes sure that the LP of the current node is loaded and
+ *          may be accessed through the LP information methods
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_191constructLP, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_constructLP, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__735)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1884, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_constructLP, __pyx_t_3) < 0) __PYX_ERR(0, 1884, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1895
+ *         return cutoff
+ * 
+ *     def getLPObjVal(self):             # <<<<<<<<<<<<<<
+ *         """gets objective value of current LP (which is the sum of column and loose objective value)"""
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_193getLPObjVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLPObjVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__736)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1895, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLPObjVal, __pyx_t_3) < 0) __PYX_ERR(0, 1895, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1900
+ *         return SCIPgetLPObjval(self._scip)
+ * 
+ *     def getLPColsData(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve current LP columns"""
+ *         cdef SCIP_COL** cols
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_195getLPColsData, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLPColsData, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__738)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1900, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLPColsData, __pyx_t_3) < 0) __PYX_ERR(0, 1900, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1908
+ *         return [Column.create(cols[i]) for i in range(ncols)]
+ * 
+ *     def getLPRowsData(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve current LP rows"""
+ *         cdef SCIP_ROW** rows
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_197getLPRowsData, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLPRowsData, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__740)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1908, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLPRowsData, __pyx_t_3) < 0) __PYX_ERR(0, 1908, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1916
+ *         return [Row.create(rows[i]) for i in range(nrows)]
+ * 
+ *     def getNLPRows(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the number of rows currently in the LP"""
+ *         return SCIPgetNLPRows(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_199getNLPRows, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNLPRows, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__741)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1916, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNLPRows, __pyx_t_3) < 0) __PYX_ERR(0, 1916, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1920
+ *         return SCIPgetNLPRows(self._scip)
+ * 
+ *     def getNLPCols(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the number of cols currently in the LP"""
+ *         return SCIPgetNLPCols(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_201getNLPCols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNLPCols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__742)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1920, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNLPCols, __pyx_t_3) < 0) __PYX_ERR(0, 1920, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1924
+ *         return SCIPgetNLPCols(self._scip)
+ * 
+ *     def getLPBasisInd(self):             # <<<<<<<<<<<<<<
+ *         """Gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1"""
+ *         cdef int nrows = SCIPgetNLPRows(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_203getLPBasisInd, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLPBasisInd, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__744)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1924, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLPBasisInd, __pyx_t_3) < 0) __PYX_ERR(0, 1924, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1934
+ *         return result
+ * 
+ *     def getLPBInvRow(self, row):             # <<<<<<<<<<<<<<
+ *         """gets a row from the inverse basis matrix B^-1"""
+ *         # TODO: sparsity information
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_205getLPBInvRow, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLPBInvRow, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__746)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1934, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLPBInvRow, __pyx_t_3) < 0) __PYX_ERR(0, 1934, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1945
+ *         return result
+ * 
+ *     def getLPBInvARow(self, row):             # <<<<<<<<<<<<<<
+ *         """gets a row from B^-1 * A"""
+ *         # TODO: sparsity information
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_207getLPBInvARow, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLPBInvARow, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__748)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1945, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLPBInvARow, __pyx_t_3) < 0) __PYX_ERR(0, 1945, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1956
+ *         return result
+ * 
+ *     def isLPSolBasic(self):             # <<<<<<<<<<<<<<
+ *         """returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis"""
+ *         return SCIPisLPSolBasic(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_209isLPSolBasic, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isLPSolBasic, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__749)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1956, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isLPSolBasic, __pyx_t_3) < 0) __PYX_ERR(0, 1956, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1962
+ *     #TODO: documentation!!
+ *     # LP Row Methods
+ *     def createEmptyRowSepa(self, Sepa sepa, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True):             # <<<<<<<<<<<<<<
+ *         """creates and captures an LP row without any coefficients from a separator
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_211createEmptyRowSepa, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createEmptyRowSepa, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__751)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1962, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__752);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createEmptyRowSepa, __pyx_t_3) < 0) __PYX_ERR(0, 1962, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1981
+ *         return PyRow
+ * 
+ *     def createEmptyRowUnspec(self, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True):             # <<<<<<<<<<<<<<
+ *         """creates and captures an LP row without any coefficients from an unspecified source
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_213createEmptyRowUnspec, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createEmptyRowUnspec, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__754)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1981, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__752);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createEmptyRowUnspec, __pyx_t_3) < 0) __PYX_ERR(0, 1981, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":1998
+ *         return PyRow
+ * 
+ *     def getRowActivity(self, Row row):             # <<<<<<<<<<<<<<
+ *         """returns the activity of a row in the last LP or pseudo solution"""
+ *         return SCIPgetRowActivity(self._scip, row.scip_row)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_215getRowActivity, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getRowActivity, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__755)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1998, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getRowActivity, __pyx_t_3) < 0) __PYX_ERR(0, 1998, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2002
+ *         return SCIPgetRowActivity(self._scip, row.scip_row)
+ * 
+ *     def getRowLPActivity(self, Row row):             # <<<<<<<<<<<<<<
+ *         """returns the activity of a row in the last LP solution"""
+ *         return SCIPgetRowLPActivity(self._scip, row.scip_row)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_217getRowLPActivity, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getRowLPActivity, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__756)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2002, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getRowLPActivity, __pyx_t_3) < 0) __PYX_ERR(0, 2002, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2007
+ * 
+ *     # TODO: do we need this? (also do we need release var??)
+ *     def releaseRow(self, Row row not None):             # <<<<<<<<<<<<<<
+ *         """decreases usage counter of LP row, and frees memory if necessary"""
+ *         PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_219releaseRow, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_releaseRow, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__757)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2007, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_releaseRow, __pyx_t_3) < 0) __PYX_ERR(0, 2007, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2011
+ *         PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row))
+ * 
+ *     def cacheRowExtensions(self, Row row not None):             # <<<<<<<<<<<<<<
+ *         """informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
+ *         after all additions were applied, flushRowExtensions() must be called;
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_221cacheRowExtensions, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_cacheRowExtensions, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__758)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2011, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_cacheRowExtensions, __pyx_t_3) < 0) __PYX_ERR(0, 2011, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2018
+ *         PY_SCIP_CALL(SCIPcacheRowExtensions(self._scip, row.scip_row))
+ * 
+ *     def flushRowExtensions(self, Row row not None):             # <<<<<<<<<<<<<<
+ *         """flushes all cached row extensions after a call of cacheRowExtensions() and merges coefficients with equal columns into a single coefficient"""
+ *         PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_223flushRowExtensions, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_flushRowExtensions, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__759)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2018, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_flushRowExtensions, __pyx_t_3) < 0) __PYX_ERR(0, 2018, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2022
+ *         PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row))
+ * 
+ *     def addVarToRow(self, Row row not None, Variable var not None, value):             # <<<<<<<<<<<<<<
+ *         """resolves variable to columns and adds them with the coefficient to the row"""
+ *         PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_225addVarToRow, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addVarToRow, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__761)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2022, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addVarToRow, __pyx_t_3) < 0) __PYX_ERR(0, 2022, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2026
+ *         PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value))
+ * 
+ *     def printRow(self, Row row not None):             # <<<<<<<<<<<<<<
+ *         """Prints row."""
+ *         PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_227printRow, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_printRow, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__762)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2026, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_printRow, __pyx_t_3) < 0) __PYX_ERR(0, 2026, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2030
+ *         PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL))
+ * 
+ *     def getRowNumIntCols(self, Row row):             # <<<<<<<<<<<<<<
+ *         """Returns number of intergal columns in the row"""
+ *         return SCIPgetRowNumIntCols(self._scip, row.scip_row)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_229getRowNumIntCols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getRowNumIntCols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__763)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2030, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getRowNumIntCols, __pyx_t_3) < 0) __PYX_ERR(0, 2030, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2034
+ *         return SCIPgetRowNumIntCols(self._scip, row.scip_row)
+ * 
+ *     def getRowObjParallelism(self, Row row):             # <<<<<<<<<<<<<<
+ *         """Returns 1 if the row is parallel, and 0 if orthogonal"""
+ *         return SCIPgetRowObjParallelism(self._scip, row.scip_row)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_231getRowObjParallelism, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getRowObjParallelism, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__764)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2034, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getRowObjParallelism, __pyx_t_3) < 0) __PYX_ERR(0, 2034, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2038
+ *         return SCIPgetRowObjParallelism(self._scip, row.scip_row)
+ * 
+ *     def getRowParallelism(self, Row row1, Row row2, orthofunc=101):             # <<<<<<<<<<<<<<
+ *         """Returns the degree of parallelism between hyplerplanes. 1 if perfectly parallel, 0 if orthognal.
+ *         101 in this case is an 'e' (euclidean) in ASCII. The other accpetable input is 100 (d for discrete)."""
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_233getRowParallelism, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getRowParallelism, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__766)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2038, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__767);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getRowParallelism, __pyx_t_3) < 0) __PYX_ERR(0, 2038, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2043
+ *         return SCIProwGetParallelism(row1.scip_row, row2.scip_row, orthofunc)
+ * 
+ *     def getRowDualSol(self, Row row):             # <<<<<<<<<<<<<<
+ *         """Gets the dual LP solution of a row"""
+ *         return SCIProwGetDualsol(row.scip_row)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_235getRowDualSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getRowDualSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__768)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2043, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getRowDualSol, __pyx_t_3) < 0) __PYX_ERR(0, 2043, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2048
+ * 
+ *     # Cutting Plane Methods
+ *     def addPoolCut(self, Row row not None):             # <<<<<<<<<<<<<<
+ *         """if not already existing, adds row to global cut pool"""
+ *         PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_237addPoolCut, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addPoolCut, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__769)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2048, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addPoolCut, __pyx_t_3) < 0) __PYX_ERR(0, 2048, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2052
+ *         PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row))
+ * 
+ *     def getCutEfficacy(self, Row cut not None, Solution sol = None):             # <<<<<<<<<<<<<<
+ *         """returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm"""
+ *         return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_239getCutEfficacy, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getCutEfficacy, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__771)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2052, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getCutEfficacy, __pyx_t_3) < 0) __PYX_ERR(0, 2052, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2056
+ *         return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row)
+ * 
+ *     def isCutEfficacious(self, Row cut not None, Solution sol = None):             # <<<<<<<<<<<<<<
+ *         """ returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy"""
+ *         return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_241isCutEfficacious, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isCutEfficacious, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__773)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2056, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isCutEfficacious, __pyx_t_3) < 0) __PYX_ERR(0, 2056, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2060
+ *         return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row)
+ * 
+ *     def getCutLPSolCutoffDistance(self, Row cut not None, Solution sol not None):             # <<<<<<<<<<<<<<
+ *         """ returns row's cutoff distance in the direction of the given primal solution"""
+ *         return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_243getCutLPSolCutoffDistance, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getCutLPSolCutoffDistance, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__774)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2060, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getCutLPSolCutoffDistance, __pyx_t_3) < 0) __PYX_ERR(0, 2060, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2064
+ *         return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row)
+ * 
+ *     def addCut(self, Row cut not None, forcecut = False):             # <<<<<<<<<<<<<<
+ *         """adds cut to separation storage and returns whether cut has been detected to be infeasible for local bounds"""
+ *         cdef SCIP_Bool infeasible
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_245addCut, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addCut, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__776)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2064, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addCut, __pyx_t_3) < 0) __PYX_ERR(0, 2064, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2070
+ *         return infeasible
+ * 
+ *     def getNCuts(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve total number of cuts in storage"""
+ *         return SCIPgetNCuts(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_247getNCuts, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNCuts, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__777)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2070, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNCuts, __pyx_t_3) < 0) __PYX_ERR(0, 2070, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2074
+ *         return SCIPgetNCuts(self._scip)
+ * 
+ *     def getNCutsApplied(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve number of currently applied cuts"""
+ *         return SCIPgetNCutsApplied(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_249getNCutsApplied, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNCutsApplied, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__778)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2074, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNCutsApplied, __pyx_t_3) < 0) __PYX_ERR(0, 2074, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2078
+ *         return SCIPgetNCutsApplied(self._scip)
+ * 
+ *     def getNSepaRounds(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the number of separation rounds that have been performed
+ *         at the current node"""
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_251getNSepaRounds, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNSepaRounds, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__779)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2078, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNSepaRounds, __pyx_t_3) < 0) __PYX_ERR(0, 2078, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2083
+ *         return SCIPgetNSepaRounds(self._scip)
+ * 
+ *     def separateSol(self, Solution sol = None, pretendroot = False, allowlocal = True, onlydelayed = False):             # <<<<<<<<<<<<<<
+ *         """separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
+ *         separation methods;
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_253separateSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_separateSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__781)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2083, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__782);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_separateSol, __pyx_t_3) < 0) __PYX_ERR(0, 2083, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2106
+ *         return delayed, cutoff
+ * 
+ *     def _createConsLinear(self, ExprCons lincons, **kwargs):             # <<<<<<<<<<<<<<
+ *         assert isinstance(lincons, ExprCons), "given constraint is not ExprCons but %s" % lincons.__class__.__name__
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_255_createConsLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model__createConsLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__784)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createConsLinear, __pyx_t_3) < 0) __PYX_ERR(0, 2106, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2136
+ *         return PyCons
+ * 
+ *     def _createConsQuadratic(self, ExprCons quadcons, **kwargs):             # <<<<<<<<<<<<<<
+ *         terms = quadcons.expr.terms
+ *         assert quadcons.expr.degree() <= 2, "given constraint is not quadratic, degree == %d" % quadcons.expr.degree()
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_257_createConsQuadratic, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model__createConsQuadratic, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__786)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createConsQuadratic, __pyx_t_3) < 0) __PYX_ERR(0, 2136, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2175
+ *         return PyCons
+ * 
+ *     def _createConsNonlinear(self, cons, **kwargs):             # <<<<<<<<<<<<<<
+ *         cdef SCIP_EXPR* expr
+ *         cdef SCIP_EXPR** varexprs
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_259_createConsNonlinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model__createConsNonlinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__788)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createConsNonlinear, __pyx_t_3) < 0) __PYX_ERR(0, 2175, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2230
+ *         return PyCons
+ * 
+ *     def _createConsGenNonlinear(self, cons, **kwargs):             # <<<<<<<<<<<<<<
+ *         cdef SCIP_EXPR** childrenexpr
+ *         cdef SCIP_EXPR** scipexprs
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_261_createConsGenNonlinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model__createConsGenNonlinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__790)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createConsGenNonlinear, __pyx_t_3) < 0) __PYX_ERR(0, 2230, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2351
+ *         return PyCons
+ * 
+ *     def createConsFromExpr(self, cons, name='', initial=True, separate=True,             # <<<<<<<<<<<<<<
+ *                 enforce=True, check=True, propagate=True, local=False,
+ *                 modifiable=False, dynamic=False, removable=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_263createConsFromExpr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createConsFromExpr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__792)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2351, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__793);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createConsFromExpr, __pyx_t_3) < 0) __PYX_ERR(0, 2351, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2397
+ * 
+ *     # Constraint functions
+ *     def addCons(self, cons, name='', initial=True, separate=True,             # <<<<<<<<<<<<<<
+ *                 enforce=True, check=True, propagate=True, local=False,
+ *                 modifiable=False, dynamic=False, removable=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_265addCons, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addCons, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__795)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2397, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__793);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addCons, __pyx_t_3) < 0) __PYX_ERR(0, 2397, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2441
+ *         return pycons
+ * 
+ *     def addConss(self, conss, name='', initial=True, separate=True,             # <<<<<<<<<<<<<<
+ *                  enforce=True, check=True, propagate=True, local=False,
+ *                  modifiable=False, dynamic=False, removable=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_267addConss, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConss, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__797)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2441, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__793);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConss, __pyx_t_3) < 0) __PYX_ERR(0, 2441, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2506
+ *         return constraints
+ * 
+ *     def addConsDisjunction(self, conss, name = '', initial = True,             # <<<<<<<<<<<<<<
+ *         relaxcons = None, enforce=True, check =True,
+ *         local=False, modifiable = False, dynamic = False):
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_269addConsDisjunction, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsDisjunction, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__799)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2506, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__800);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsDisjunction, __pyx_t_3) < 0) __PYX_ERR(0, 2506, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2557
+ *         return PyCons
+ * 
+ *     def addConsElemDisjunction(self, Constraint disj_cons, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Appends a constraint to a disjunction.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_271addConsElemDisjunction, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsElemDisjunction, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__802)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2557, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsElemDisjunction, __pyx_t_3) < 0) __PYX_ERR(0, 2557, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2568
+ *         return disj_cons
+ * 
+ *     def getConsNVars(self, Constraint constraint):             # <<<<<<<<<<<<<<
+ *         """
+ *         Gets number of variables in a constraint.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_273getConsNVars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getConsNVars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__804)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2568, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getConsNVars, __pyx_t_3) < 0) __PYX_ERR(0, 2568, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2586
+ *         return nvars
+ * 
+ *     def getConsVars(self, Constraint constraint):             # <<<<<<<<<<<<<<
+ *         """
+ *         Gets variables in a constraint.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_275getConsVars, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getConsVars, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__806)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2586, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getConsVars, __pyx_t_3) < 0) __PYX_ERR(0, 2586, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2614
+ *         return vars
+ * 
+ *     def printCons(self, Constraint constraint):             # <<<<<<<<<<<<<<
+ *         return PY_SCIP_CALL(SCIPprintCons(self._scip, constraint.scip_cons, NULL))
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_277printCons, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_printCons, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__807)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2614, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_printCons, __pyx_t_3) < 0) __PYX_ERR(0, 2614, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2618
+ * 
+ *     # TODO Find a better way to retrieve a scip expression from a python expression. Consider making GenExpr include Expr, to avoid using Union. See PR #760.
+ *     from typing import Union             # <<<<<<<<<<<<<<
+ *     def addExprNonlinear(self, Constraint cons, expr: Union[Expr,GenExpr], float coef):
+ *         """
+ */
+  __pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2618, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(__pyx_n_s_Union);
+  __Pyx_GIVEREF(__pyx_n_s_Union);
+  if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_n_s_Union)) __PYX_ERR(0, 2618, __pyx_L1_error);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_typing, __pyx_t_3, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2618, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Union); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2618, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_Union, __pyx_t_3) < 0) __PYX_ERR(0, 2618, __pyx_L1_error)
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":2619
+ *     # TODO Find a better way to retrieve a scip expression from a python expression. Consider making GenExpr include Expr, to avoid using Union. See PR #760.
+ *     from typing import Union
+ *     def addExprNonlinear(self, Constraint cons, expr: Union[Expr,GenExpr], float coef):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add coef*expr to nonlinear constraint.
+ */
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2619, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_expr, __pyx_kp_s_Union_Expr_GenExpr) < 0) __PYX_ERR(0, 2619, __pyx_L1_error)
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_279addExprNonlinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addExprNonlinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__809)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2619, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_3, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addExprNonlinear, __pyx_t_3) < 0) __PYX_ERR(0, 2619, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2635
+ *         self.delCons(temp_cons)
+ * 
+ *     def addConsCoeff(self, Constraint cons, Variable var, coeff):             # <<<<<<<<<<<<<<
+ *         """Add coefficient to the linear constraint (if non-zero).
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_281addConsCoeff, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsCoeff, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__811)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2635, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsCoeff, __pyx_t_3) < 0) __PYX_ERR(0, 2635, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2645
+ *         PY_SCIP_CALL(SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, coeff))
+ * 
+ *     def addConsNode(self, Node node, Constraint cons, Node validnode=None):             # <<<<<<<<<<<<<<
+ *         """Add a constraint to the given node
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_283addConsNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__813)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2645, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsNode, __pyx_t_3) < 0) __PYX_ERR(0, 2645, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2659
+ *         Py_INCREF(cons)
+ * 
+ *     def addConsLocal(self, Constraint cons, Node validnode=None):             # <<<<<<<<<<<<<<
+ *         """Add a constraint to the current node
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_285addConsLocal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsLocal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__815)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2659, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsLocal, __pyx_t_3) < 0) __PYX_ERR(0, 2659, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2672
+ *         Py_INCREF(cons)
+ * 
+ *     def addConsSOS1(self, vars, weights=None, name="SOS1cons",             # <<<<<<<<<<<<<<
+ *                 initial=True, separate=True, enforce=True, check=True,
+ *                 propagate=True, local=False, dynamic=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_287addConsSOS1, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsSOS1, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__817)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2672, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__818);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsSOS1, __pyx_t_3) < 0) __PYX_ERR(0, 2672, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2711
+ *         return Constraint.create(scip_cons)
+ * 
+ *     def addConsSOS2(self, vars, weights=None, name="SOS2cons",             # <<<<<<<<<<<<<<
+ *                 initial=True, separate=True, enforce=True, check=True,
+ *                 propagate=True, local=False, dynamic=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_289addConsSOS2, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsSOS2, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__819)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2711, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__820);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsSOS2, __pyx_t_3) < 0) __PYX_ERR(0, 2711, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2750
+ *         return Constraint.create(scip_cons)
+ * 
+ *     def addConsAnd(self, vars, resvar, name="ANDcons",             # <<<<<<<<<<<<<<
+ *             initial=True, separate=True, enforce=True, check=True,
+ *             propagate=True, local=False, modifiable=False, dynamic=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_291addConsAnd, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsAnd, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__822)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2750, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__823);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsAnd, __pyx_t_3) < 0) __PYX_ERR(0, 2750, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2789
+ *         return pyCons
+ * 
+ *     def addConsOr(self, vars, resvar, name="ORcons",             # <<<<<<<<<<<<<<
+ *             initial=True, separate=True, enforce=True, check=True,
+ *             propagate=True, local=False, modifiable=False, dynamic=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_293addConsOr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsOr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__824)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2789, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__825);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsOr, __pyx_t_3) < 0) __PYX_ERR(0, 2789, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2828
+ *         return pyCons
+ * 
+ *     def addConsXor(self, vars, rhsvar, name="XORcons",             # <<<<<<<<<<<<<<
+ *             initial=True, separate=True, enforce=True, check=True,
+ *             propagate=True, local=False, modifiable=False, dynamic=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_295addConsXor, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsXor, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__827)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2828, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__828);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsXor, __pyx_t_3) < 0) __PYX_ERR(0, 2828, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2867
+ *         return pyCons
+ * 
+ *     def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons",             # <<<<<<<<<<<<<<
+ *                 initial=True, separate=True, enforce=True, check=True,
+ *                 propagate=True, local=False, dynamic=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_297addConsCardinality, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsCardinality, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__830)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2867, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__831);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsCardinality, __pyx_t_3) < 0) __PYX_ERR(0, 2867, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2917
+ *         return pyCons
+ * 
+ *     def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons",             # <<<<<<<<<<<<<<
+ *                 initial=True, separate=True, enforce=True, check=True,
+ *                 propagate=True, local=False, dynamic=False,
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_299addConsIndicator, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addConsIndicator, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__833)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2917, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__834);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addConsIndicator, __pyx_t_3) < 0) __PYX_ERR(0, 2917, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2981
+ *         return pyCons
+ * 
+ *     def getSlackVarIndicator(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Get slack variable of an indicator constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_301getSlackVarIndicator, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getSlackVarIndicator, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__836)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2981, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getSlackVarIndicator, __pyx_t_3) < 0) __PYX_ERR(0, 2981, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2990
+ *         return Variable.create(var)
+ * 
+ *     def addPyCons(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Adds a customly created cons.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_303addPyCons, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addPyCons, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__838)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2990, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addPyCons, __pyx_t_3) < 0) __PYX_ERR(0, 2990, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":2999
+ *         Py_INCREF(cons)
+ * 
+ *     def addVarSOS1(self, Constraint cons, Variable var, weight):             # <<<<<<<<<<<<<<
+ *         """Add variable to SOS1 constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_305addVarSOS1, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addVarSOS1, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__840)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2999, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addVarSOS1, __pyx_t_3) < 0) __PYX_ERR(0, 2999, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3009
+ *         PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, cons.scip_cons, var.scip_var, weight))
+ * 
+ *     def appendVarSOS1(self, Constraint cons, Variable var):             # <<<<<<<<<<<<<<
+ *         """Append variable to SOS1 constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_307appendVarSOS1, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_appendVarSOS1, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__841)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3009, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_appendVarSOS1, __pyx_t_3) < 0) __PYX_ERR(0, 3009, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3018
+ *         PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, cons.scip_cons, var.scip_var))
+ * 
+ *     def addVarSOS2(self, Constraint cons, Variable var, weight):             # <<<<<<<<<<<<<<
+ *         """Add variable to SOS2 constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_309addVarSOS2, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addVarSOS2, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__842)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3018, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addVarSOS2, __pyx_t_3) < 0) __PYX_ERR(0, 3018, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3028
+ *         PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, cons.scip_cons, var.scip_var, weight))
+ * 
+ *     def appendVarSOS2(self, Constraint cons, Variable var):             # <<<<<<<<<<<<<<
+ *         """Append variable to SOS2 constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_311appendVarSOS2, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_appendVarSOS2, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__843)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3028, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_appendVarSOS2, __pyx_t_3) < 0) __PYX_ERR(0, 3028, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3037
+ *         PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, cons.scip_cons, var.scip_var))
+ * 
+ *     def setInitial(self, Constraint cons, newInit):             # <<<<<<<<<<<<<<
+ *         """Set "initial" flag of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_313setInitial, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setInitial, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__845)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3037, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setInitial, __pyx_t_3) < 0) __PYX_ERR(0, 3037, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3046
+ *         PY_SCIP_CALL(SCIPsetConsInitial(self._scip, cons.scip_cons, newInit))
+ * 
+ *     def setRemovable(self, Constraint cons, newRem):             # <<<<<<<<<<<<<<
+ *         """Set "removable" flag of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_315setRemovable, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setRemovable, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__847)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3046, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setRemovable, __pyx_t_3) < 0) __PYX_ERR(0, 3046, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3055
+ *         PY_SCIP_CALL(SCIPsetConsRemovable(self._scip, cons.scip_cons, newRem))
+ * 
+ *     def setEnforced(self, Constraint cons, newEnf):             # <<<<<<<<<<<<<<
+ *         """Set "enforced" flag of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_317setEnforced, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setEnforced, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__849)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3055, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setEnforced, __pyx_t_3) < 0) __PYX_ERR(0, 3055, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3064
+ *         PY_SCIP_CALL(SCIPsetConsEnforced(self._scip, cons.scip_cons, newEnf))
+ * 
+ *     def setCheck(self, Constraint cons, newCheck):             # <<<<<<<<<<<<<<
+ *         """Set "check" flag of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_319setCheck, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setCheck, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__851)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3064, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setCheck, __pyx_t_3) < 0) __PYX_ERR(0, 3064, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3073
+ *         PY_SCIP_CALL(SCIPsetConsChecked(self._scip, cons.scip_cons, newCheck))
+ * 
+ *     def chgRhs(self, Constraint cons, rhs):             # <<<<<<<<<<<<<<
+ *         """Change right hand side value of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_321chgRhs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgRhs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__853)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3073, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgRhs, __pyx_t_3) < 0) __PYX_ERR(0, 3073, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3092
+ *             raise Warning("method cannot be called for constraints of type " + constype)
+ * 
+ *     def chgLhs(self, Constraint cons, lhs):             # <<<<<<<<<<<<<<
+ *         """Change left hand side value of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_323chgLhs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgLhs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__855)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3092, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgLhs, __pyx_t_3) < 0) __PYX_ERR(0, 3092, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3111
+ *             raise Warning("method cannot be called for constraints of type " + constype)
+ * 
+ *     def getRhs(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Retrieve right hand side value of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_325getRhs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getRhs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__857)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getRhs, __pyx_t_3) < 0) __PYX_ERR(0, 3111, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3125
+ *             raise Warning("method cannot be called for constraints of type " + constype)
+ * 
+ *     def getLhs(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Retrieve left hand side value of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_327getLhs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLhs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__858)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLhs, __pyx_t_3) < 0) __PYX_ERR(0, 3125, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3139
+ *             raise Warning("method cannot be called for constraints of type " + constype)
+ * 
+ *     def chgCoefLinear(self, Constraint cons, Variable var, value):             # <<<<<<<<<<<<<<
+ *         """Changes coefficient of variable in linear constraint;
+ *         deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_329chgCoefLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgCoefLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__860)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgCoefLinear, __pyx_t_3) < 0) __PYX_ERR(0, 3139, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3152
+ *         PY_SCIP_CALL( SCIPchgCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) )
+ * 
+ *     def delCoefLinear(self, Constraint cons, Variable var):             # <<<<<<<<<<<<<<
+ *         """Deletes variable from linear constraint
+ *         This method may only be called during problem creation stage for an original constraint and variable.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_331delCoefLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_delCoefLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__861)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3152, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_delCoefLinear, __pyx_t_3) < 0) __PYX_ERR(0, 3152, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3164
+ *         PY_SCIP_CALL( SCIPdelCoefLinear(self._scip, cons.scip_cons, var.scip_var) )
+ * 
+ *     def addCoefLinear(self, Constraint cons, Variable var, value):             # <<<<<<<<<<<<<<
+ *         """Adds coefficient to linear constraint (if it is not zero)
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_333addCoefLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addCoefLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__862)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3164, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addCoefLinear, __pyx_t_3) < 0) __PYX_ERR(0, 3164, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3175
+ *         PY_SCIP_CALL( SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) )
+ * 
+ *     def getActivity(self, Constraint cons, Solution sol = None):             # <<<<<<<<<<<<<<
+ *         """Retrieve activity of given constraint.
+ *         Can only be called after solving is completed.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_335getActivity, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getActivity, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__864)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getActivity, __pyx_t_3) < 0) __PYX_ERR(0, 3175, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3203
+ * 
+ * 
+ *     def getSlack(self, Constraint cons, Solution sol = None, side = None):             # <<<<<<<<<<<<<<
+ *         """Retrieve slack of given constraint.
+ *         Can only be called after solving is completed.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_337getSlack, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getSlack, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__866)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__212);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getSlack, __pyx_t_3) < 0) __PYX_ERR(0, 3203, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3243
+ *             return min(lhsslack, rhsslack)
+ * 
+ *     def getTransformedCons(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Retrieve transformed constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_339getTransformedCons, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getTransformedCons, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__868)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3243, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getTransformedCons, __pyx_t_3) < 0) __PYX_ERR(0, 3243, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3253
+ *         return Constraint.create(transcons)
+ * 
+ *     def isNLPConstructed(self):             # <<<<<<<<<<<<<<
+ *         """returns whether SCIP's internal NLP has been constructed"""
+ *         return SCIPisNLPConstructed(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_341isNLPConstructed, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isNLPConstructed, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__869)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isNLPConstructed, __pyx_t_3) < 0) __PYX_ERR(0, 3253, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3257
+ *         return SCIPisNLPConstructed(self._scip)
+ * 
+ *     def getNNlRows(self):             # <<<<<<<<<<<<<<
+ *         """gets current number of nonlinear rows in SCIP's internal NLP"""
+ *         return SCIPgetNNLPNlRows(self._scip)
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_343getNNlRows, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNNlRows, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__870)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3257, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNNlRows, __pyx_t_3) < 0) __PYX_ERR(0, 3257, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3261
+ *         return SCIPgetNNLPNlRows(self._scip)
+ * 
+ *     def getNlRows(self):             # <<<<<<<<<<<<<<
+ *         """returns a list with the nonlinear rows in SCIP's internal NLP"""
+ *         cdef SCIP_NLROW** nlrows
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_345getNlRows, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNlRows, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__872)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3261, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNlRows, __pyx_t_3) < 0) __PYX_ERR(0, 3261, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3268
+ *         return [NLRow.create(nlrows[i]) for i in range(self.getNNlRows())]
+ * 
+ *     def getNlRowSolActivity(self, NLRow nlrow, Solution sol = None):             # <<<<<<<<<<<<<<
+ *         """gives the activity of a nonlinear row for a given primal solution
+ *         Keyword arguments:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_347getNlRowSolActivity, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNlRowSolActivity, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__874)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3268, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNlRowSolActivity, __pyx_t_3) < 0) __PYX_ERR(0, 3268, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3281
+ *         return activity
+ * 
+ *     def getNlRowSolFeasibility(self, NLRow nlrow, Solution sol = None):             # <<<<<<<<<<<<<<
+ *         """gives the feasibility of a nonlinear row for a given primal solution
+ *         Keyword arguments:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_349getNlRowSolFeasibility, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNlRowSolFeasibility, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__876)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3281, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNlRowSolFeasibility, __pyx_t_3) < 0) __PYX_ERR(0, 3281, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3294
+ *         return feasibility
+ * 
+ *     def getNlRowActivityBounds(self, NLRow nlrow):             # <<<<<<<<<<<<<<
+ *         """gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds"""
+ *         cdef SCIP_Real minactivity
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_351getNlRowActivityBounds, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNlRowActivityBounds, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__878)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3294, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNlRowActivityBounds, __pyx_t_3) < 0) __PYX_ERR(0, 3294, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3302
+ *         return (minactivity, maxactivity)
+ * 
+ *     def printNlRow(self, NLRow nlrow):             # <<<<<<<<<<<<<<
+ *         """prints nonlinear row"""
+ *         PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) )
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_353printNlRow, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_printNlRow, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__880)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3302, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_printNlRow, __pyx_t_3) < 0) __PYX_ERR(0, 3302, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3306
+ *         PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) )
+ * 
+ *     def checkQuadraticNonlinear(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """returns if the given constraint is quadratic
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_355checkQuadraticNonlinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_checkQuadraticNonlinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__882)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3306, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_checkQuadraticNonlinear, __pyx_t_3) < 0) __PYX_ERR(0, 3306, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3316
+ *         return isquadratic
+ * 
+ *     def getTermsQuadratic(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Retrieve bilinear, quadratic, and linear terms of a quadratic constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_357getTermsQuadratic, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getTermsQuadratic, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__884)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3316, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getTermsQuadratic, __pyx_t_3) < 0) __PYX_ERR(0, 3316, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3379
+ *         return (bilinterms, quadterms, linterms)
+ * 
+ *     def setRelaxSolVal(self, Variable var, val):             # <<<<<<<<<<<<<<
+ *         """sets the value of the given variable in the global relaxation solution"""
+ *         PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_359setRelaxSolVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setRelaxSolVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__886)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3379, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setRelaxSolVal, __pyx_t_3) < 0) __PYX_ERR(0, 3379, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3383
+ *         PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val))
+ * 
+ *     def getConss(self, transformed=True):             # <<<<<<<<<<<<<<
+ *         """Retrieve all constraints.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_361getConss, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getConss, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__888)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3383, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getConss, __pyx_t_3) < 0) __PYX_ERR(0, 3383, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3400
+ *         return [Constraint.create(_conss[i]) for i in range(_nconss)]
+ * 
+ *     def getNConss(self, transformed=True):             # <<<<<<<<<<<<<<
+ *         """Retrieve number of all constraints"""
+ *         if transformed:
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_363getNConss, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNConss, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__889)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3400, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNConss, __pyx_t_3) < 0) __PYX_ERR(0, 3400, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3407
+ *             return SCIPgetNOrigConss(self._scip)
+ * 
+ *     def delCons(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Delete constraint from the model
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_365delCons, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_delCons, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__890)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3407, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_delCons, __pyx_t_3) < 0) __PYX_ERR(0, 3407, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3415
+ *         PY_SCIP_CALL(SCIPdelCons(self._scip, cons.scip_cons))
+ * 
+ *     def delConsLocal(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Delete constraint from the current node and it's children
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_367delConsLocal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_delConsLocal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__891)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3415, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_delConsLocal, __pyx_t_3) < 0) __PYX_ERR(0, 3415, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3423
+ *         PY_SCIP_CALL(SCIPdelConsLocal(self._scip, cons.scip_cons))
+ * 
+ *     def getValsLinear(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Retrieve the coefficients of a linear constraint
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_369getValsLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getValsLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__893)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getValsLinear, __pyx_t_3) < 0) __PYX_ERR(0, 3423, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3444
+ *         return valsdict
+ * 
+ *     def getRowLinear(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Retrieve the linear relaxation of the given linear constraint as a row.
+ *            may return NULL if no LP row was yet created; the user must not modify the row!
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_371getRowLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getRowLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__895)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3444, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getRowLinear, __pyx_t_3) < 0) __PYX_ERR(0, 3444, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3458
+ *         return Row.create(row)
+ * 
+ *     def getDualsolLinear(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Retrieve the dual solution to a linear constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_373getDualsolLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getDualsolLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__897)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3458, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getDualsolLinear, __pyx_t_3) < 0) __PYX_ERR(0, 3458, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3473
+ *         return SCIPgetDualsolLinear(self._scip, transcons.scip_cons)
+ * 
+ *     def getDualMultiplier(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """DEPRECATED: Retrieve the dual solution to a linear constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_375getDualMultiplier, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getDualMultiplier, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__898)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3473, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getDualMultiplier, __pyx_t_3) < 0) __PYX_ERR(0, 3473, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3482
+ *         return self.getDualsolLinear(cons)
+ * 
+ *     def getDualfarkasLinear(self, Constraint cons):             # <<<<<<<<<<<<<<
+ *         """Retrieve the dual farkas value to a linear constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_377getDualfarkasLinear, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getDualfarkasLinear, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__899)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3482, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getDualfarkasLinear, __pyx_t_3) < 0) __PYX_ERR(0, 3482, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3495
+ *             return SCIPgetDualfarkasLinear(self._scip, cons.scip_cons)
+ * 
+ *     def getVarRedcost(self, Variable var):             # <<<<<<<<<<<<<<
+ *         """Retrieve the reduced cost of a variable.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_379getVarRedcost, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getVarRedcost, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__901)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3495, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getVarRedcost, __pyx_t_3) < 0) __PYX_ERR(0, 3495, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3510
+ *         return redcost
+ * 
+ *     def getDualSolVal(self, Constraint cons, boundconstraint=False):             # <<<<<<<<<<<<<<
+ *         """Retrieve returns dual solution value of a constraint.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_381getDualSolVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getDualSolVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__903)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3510, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getDualSolVal, __pyx_t_3) < 0) __PYX_ERR(0, 3510, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3527
+ *         return _dualsol
+ * 
+ *     def optimize(self):             # <<<<<<<<<<<<<<
+ *         """Optimize the problem."""
+ *         PY_SCIP_CALL(SCIPsolve(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_383optimize, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_optimize, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__904)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3527, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_optimize, __pyx_t_3) < 0) __PYX_ERR(0, 3527, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3532
+ *         self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip))
+ * 
+ *     def solveConcurrent(self):             # <<<<<<<<<<<<<<
+ *         """Transforms, presolves, and solves problem using additional solvers which emphasize on
+ *         finding solutions."""
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_385solveConcurrent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_solveConcurrent, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__905)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3532, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_solveConcurrent, __pyx_t_3) < 0) __PYX_ERR(0, 3532, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3542
+ *             self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip))
+ * 
+ *     def presolve(self):             # <<<<<<<<<<<<<<
+ *         """Presolve the problem."""
+ *         PY_SCIP_CALL(SCIPpresolve(self._scip))
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_387presolve, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_presolve, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__906)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3542, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_presolve, __pyx_t_3) < 0) __PYX_ERR(0, 3542, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3547
+ * 
+ *     # Benders' decomposition methods
+ *     def initBendersDefault(self, subproblems):             # <<<<<<<<<<<<<<
+ *         """initialises the default Benders' decomposition with a dictionary of subproblems
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_389initBendersDefault, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_initBendersDefault, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__908)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3547, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_initBendersDefault, __pyx_t_3) < 0) __PYX_ERR(0, 3547, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3583
+ *         #self.setIntParam("limits/maxorigsol", 0)
+ * 
+ *     def computeBestSolSubproblems(self):             # <<<<<<<<<<<<<<
+ *         """Solves the subproblems with the best solution to the master problem.
+ *         Afterwards, the best solution from each subproblem can be queried to get
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_391computeBestSolSubproblems, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_computeBestSolSubproblems, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__910)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3583, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_computeBestSolSubproblems, __pyx_t_3) < 0) __PYX_ERR(0, 3583, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3610
+ *                     _benders[i], self._bestSol.sol, j, &_infeasible, solvecip, NULL))
+ * 
+ *     def freeBendersSubproblems(self):             # <<<<<<<<<<<<<<
+ *         """Calls the free subproblem function for the Benders' decomposition.
+ *         This will free all subproblems for all decompositions.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_393freeBendersSubproblems, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_freeBendersSubproblems, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__912)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3610, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_freeBendersSubproblems, __pyx_t_3) < 0) __PYX_ERR(0, 3610, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3628
+ *                     j))
+ * 
+ *     def updateBendersLowerbounds(self, lowerbounds, Benders benders=None):             # <<<<<<<<<<<<<<
+ *         """"updates the subproblem lower bounds for benders using
+ *         the lowerbounds dict. If benders is None, then the default
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_395updateBendersLowerbounds, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_updateBendersLowerbounds, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__914)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3628, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_updateBendersLowerbounds, __pyx_t_3) < 0) __PYX_ERR(0, 3628, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3645
+ *             SCIPbendersUpdateSubproblemLowerbound(_benders, d, lowerbounds[d])
+ * 
+ *     def activateBenders(self, Benders benders, int nsubproblems):             # <<<<<<<<<<<<<<
+ *         """Activates the Benders' decomposition plugin with the input name
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_397activateBenders, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_activateBenders, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__916)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3645, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_activateBenders, __pyx_t_3) < 0) __PYX_ERR(0, 3645, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3654
+ *         PY_SCIP_CALL(SCIPactivateBenders(self._scip, benders._benders, nsubproblems))
+ * 
+ *     def addBendersSubproblem(self, Benders benders, subproblem):             # <<<<<<<<<<<<<<
+ *         """adds a subproblem to the Benders' decomposition given by the input
+ *         name.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_399addBendersSubproblem, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addBendersSubproblem, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__918)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3654, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addBendersSubproblem, __pyx_t_3) < 0) __PYX_ERR(0, 3654, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3665
+ *         PY_SCIP_CALL(SCIPaddBendersSubproblem(self._scip, benders._benders, (subproblem)._scip))
+ * 
+ *     def setBendersSubproblemIsConvex(self, Benders benders, probnumber, isconvex = True):             # <<<<<<<<<<<<<<
+ *         """sets a flag indicating whether the subproblem is convex
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_401setBendersSubproblemIsConvex, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setBendersSubproblemIsConv, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__920)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3665, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setBendersSubproblemIsConvex, __pyx_t_3) < 0) __PYX_ERR(0, 3665, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3675
+ *         SCIPbendersSetSubproblemIsConvex(benders._benders, probnumber, isconvex)
+ * 
+ *     def setupBendersSubproblem(self, probnumber, Benders benders = None, Solution solution = None, checktype = PY_SCIP_BENDERSENFOTYPE.LP):             # <<<<<<<<<<<<<<
+ *         """ sets up the Benders' subproblem given the master problem solution
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE), __pyx_n_s_LP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3675, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_k__101 = __pyx_t_3;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_BENDERSENFOTYPE), __pyx_n_s_LP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3675, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3675, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, Py_None)) __PYX_ERR(0, 3675, __pyx_L1_error);
+  __Pyx_INCREF(Py_None);
+  __Pyx_GIVEREF(Py_None);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None)) __PYX_ERR(0, 3675, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_3)) __PYX_ERR(0, 3675, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_403setupBendersSubproblem, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setupBendersSubproblem, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__922)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3675, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_t_2);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setupBendersSubproblem, __pyx_t_3) < 0) __PYX_ERR(0, 3675, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3702
+ *         PY_SCIP_CALL(retcode)
+ * 
+ *     def solveBendersSubproblem(self, probnumber, solvecip, Benders benders = None, Solution solution = None):             # <<<<<<<<<<<<<<
+ *         """ solves the Benders' decomposition subproblem. The convex relaxation will be solved unless
+ *         the parameter solvecip is set to True.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_405solveBendersSubproblem, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_solveBendersSubproblem, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__924)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3702, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__212);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_solveBendersSubproblem, __pyx_t_3) < 0) __PYX_ERR(0, 3702, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3733
+ *         return infeasible, objective
+ * 
+ *     def getBendersSubproblem(self, probnumber, Benders benders = None):             # <<<<<<<<<<<<<<
+ *         """Returns a Model object that wraps around the SCIP instance of the subproblem.
+ *         NOTE: This Model object is just a place holder and SCIP instance will not be freed when the object is destroyed.
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_407getBendersSubproblem, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBendersSubproblem, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__926)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3733, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBendersSubproblem, __pyx_t_3) < 0) __PYX_ERR(0, 3733, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3753
+ *         return Model.create(scip_subprob)
+ * 
+ *     def getBendersVar(self, Variable var, Benders benders = None, probnumber = -1):             # <<<<<<<<<<<<<<
+ *         """Returns the variable for the subproblem or master problem
+ *         depending on the input probnumber
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_409getBendersVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBendersVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__928)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3753, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__929);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBendersVar, __pyx_t_3) < 0) __PYX_ERR(0, 3753, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3782
+ *         return mappedvar
+ * 
+ *     def getBendersAuxiliaryVar(self, probnumber, Benders benders = None):             # <<<<<<<<<<<<<<
+ *         """Returns the auxiliary variable that is associated with the input problem number
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_411getBendersAuxiliaryVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBendersAuxiliaryVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__931)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3782, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBendersAuxiliaryVar, __pyx_t_3) < 0) __PYX_ERR(0, 3782, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3802
+ *         return auxvar
+ * 
+ *     def checkBendersSubproblemOptimality(self, Solution solution, probnumber, Benders benders = None):             # <<<<<<<<<<<<<<
+ *         """Returns whether the subproblem is optimal w.r.t the master problem auxiliary variables.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_413checkBendersSubproblemOptimality, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_checkBendersSubproblemOpti, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__933)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3802, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_checkBendersSubproblemOptimality, __pyx_t_3) < 0) __PYX_ERR(0, 3802, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3829
+ *         return optimal
+ * 
+ *     def includeBendersDefaultCuts(self, Benders benders):             # <<<<<<<<<<<<<<
+ *         """includes the default Benders' decomposition cuts to the custom Benders' decomposition plugin
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_415includeBendersDefaultCuts, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeBendersDefaultCuts, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__935)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3829, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeBendersDefaultCuts, __pyx_t_3) < 0) __PYX_ERR(0, 3829, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3838
+ * 
+ * 
+ *     def includeEventhdlr(self, Eventhdlr eventhdlr, name, desc):             # <<<<<<<<<<<<<<
+ *         """Include an event handler.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_417includeEventhdlr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeEventhdlr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__937)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3838, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeEventhdlr, __pyx_t_3) < 0) __PYX_ERR(0, 3838, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3862
+ *         Py_INCREF(eventhdlr)
+ * 
+ *     def includePricer(self, Pricer pricer, name, desc, priority=1, delay=True):             # <<<<<<<<<<<<<<
+ *         """Include a pricer.
+ * 
+ */
+  __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_419includePricer, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includePricer, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__939)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3862, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__940);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includePricer, __pyx_t_3) < 0) __PYX_ERR(0, 3862, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3888
+ *                         eagerfreq=100, maxprerounds=-1, delaysepa=False,
+ *                         delayprop=False, needscons=True,
+ *                         proptiming=PY_SCIP_PROPTIMING.BEFORELP,             # <<<<<<<<<<<<<<
+ *                         presoltiming=PY_SCIP_PRESOLTIMING.MEDIUM):
+ *         """Include a constraint handler
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING), __pyx_n_s_BEFORELP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3888, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_k__102 = __pyx_t_3;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "src/pyscipopt/scip.pxi":3889
+ *                         delayprop=False, needscons=True,
+ *                         proptiming=PY_SCIP_PROPTIMING.BEFORELP,
+ *                         presoltiming=PY_SCIP_PRESOLTIMING.MEDIUM):             # <<<<<<<<<<<<<<
+ *         """Include a constraint handler
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING), __pyx_n_s_MEDIUM); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3889, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_k__103 = __pyx_t_3;
+  __Pyx_GIVEREF(__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "src/pyscipopt/scip.pxi":3888
+ *                         eagerfreq=100, maxprerounds=-1, delaysepa=False,
+ *                         delayprop=False, needscons=True,
+ *                         proptiming=PY_SCIP_PROPTIMING.BEFORELP,             # <<<<<<<<<<<<<<
+ *                         presoltiming=PY_SCIP_PRESOLTIMING.MEDIUM):
+ *         """Include a constraint handler
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PROPTIMING), __pyx_n_s_BEFORELP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3888, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+
+  /* "src/pyscipopt/scip.pxi":3889
+ *                         delayprop=False, needscons=True,
+ *                         proptiming=PY_SCIP_PROPTIMING.BEFORELP,
+ *                         presoltiming=PY_SCIP_PRESOLTIMING.MEDIUM):             # <<<<<<<<<<<<<<
+ *         """Include a constraint handler
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_9pyscipopt_4scip_PY_SCIP_PRESOLTIMING), __pyx_n_s_MEDIUM); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3889, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "src/pyscipopt/scip.pxi":3884
+ *         Py_INCREF(pricer)
+ * 
+ *     def includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0,             # <<<<<<<<<<<<<<
+ *                         enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1,
+ *                         eagerfreq=100, maxprerounds=-1, delaysepa=False,
+ */
+  __pyx_t_4 = PyTuple_New(12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3884, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_0)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_0)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_int_0)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_neg_1);
+  __Pyx_GIVEREF(__pyx_int_neg_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_int_neg_1)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_neg_1);
+  __Pyx_GIVEREF(__pyx_int_neg_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_int_neg_1)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_100);
+  __Pyx_GIVEREF(__pyx_int_100);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 5, __pyx_int_100)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_neg_1);
+  __Pyx_GIVEREF(__pyx_int_neg_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 6, __pyx_int_neg_1)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(Py_False);
+  __Pyx_GIVEREF(Py_False);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 7, Py_False)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(Py_False);
+  __Pyx_GIVEREF(Py_False);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 8, Py_False)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_INCREF(Py_True);
+  __Pyx_GIVEREF(Py_True);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 9, Py_True)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_3);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 10, __pyx_t_3)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 11, __pyx_t_2)) __PYX_ERR(0, 3884, __pyx_L1_error);
+  __pyx_t_3 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_421includeConshdlr, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeConshdlr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__942)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3884, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeConshdlr, __pyx_t_2) < 0) __PYX_ERR(0, 3884, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3923
+ *         Py_INCREF(conshdlr)
+ * 
+ *     def createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True,             # <<<<<<<<<<<<<<
+ *                    local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False):
+ *         """Create a constraint of a custom constraint handler
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_423createCons, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createCons, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__944)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3923, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__945);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createCons, __pyx_t_2) < 0) __PYX_ERR(0, 3923, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3950
+ *         return constraint
+ * 
+ *     def includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=SCIP_PRESOLTIMING_FAST):             # <<<<<<<<<<<<<<
+ *         """Include a presolver
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING_FAST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3950, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_k__104 = __pyx_t_2;
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING_FAST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3950, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3950, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 3950, __pyx_L1_error);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_425includePresol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includePresol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__947)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3950, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includePresol, __pyx_t_2) < 0) __PYX_ERR(0, 3950, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3968
+ *         Py_INCREF(presol)
+ * 
+ *     def includeSepa(self, Sepa sepa, name, desc, priority=0, freq=10, maxbounddist=1.0, usessubscip=False, delay=False):             # <<<<<<<<<<<<<<
+ *         """Include a separator
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_427includeSepa, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeSepa, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__949)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3968, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__950);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeSepa, __pyx_t_2) < 0) __PYX_ERR(0, 3968, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":3989
+ *         Py_INCREF(sepa)
+ * 
+ *     def includeReader(self, Reader reader, name, desc, ext):             # <<<<<<<<<<<<<<
+ *         """Include a reader
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_429includeReader, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeReader, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__952)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3989, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeReader, __pyx_t_2) < 0) __PYX_ERR(0, 3989, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4008
+ * 
+ *     def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds,
+ *                     proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True):             # <<<<<<<<<<<<<<
+ *         """Include a propagator.
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING_FAST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4008, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_k__105 = __pyx_t_2;
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":4007
+ *         Py_INCREF(reader)
+ * 
+ *     def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds,             # <<<<<<<<<<<<<<
+ *                     proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True):
+ *         """Include a propagator.
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING_FAST); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4008, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "src/pyscipopt/scip.pxi":4008
+ * 
+ *     def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds,
+ *                     proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True):             # <<<<<<<<<<<<<<
+ *         """Include a propagator.
+ * 
+ */
+  __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4007, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2)) __PYX_ERR(0, 4007, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_1)) __PYX_ERR(0, 4007, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_int_1)) __PYX_ERR(0, 4007, __pyx_L1_error);
+  __Pyx_INCREF(Py_True);
+  __Pyx_GIVEREF(Py_True);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, Py_True)) __PYX_ERR(0, 4007, __pyx_L1_error);
+  __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":4007
+ *         Py_INCREF(reader)
+ * 
+ *     def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds,             # <<<<<<<<<<<<<<
+ *                     proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True):
+ *         """Include a propagator.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_431includeProp, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeProp, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__954)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4007, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeProp, __pyx_t_2) < 0) __PYX_ERR(0, 4007, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4036
+ * 
+ *     def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0,
+ *                     maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False):             # <<<<<<<<<<<<<<
+ *         """Include a primal heuristic.
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_BEFORENODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4036, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_k__106 = __pyx_t_2;
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":4035
+ *         Py_INCREF(prop)
+ * 
+ *     def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0,             # <<<<<<<<<<<<<<
+ *                     maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False):
+ *         """Include a primal heuristic.
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING_BEFORENODE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4036, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+
+  /* "src/pyscipopt/scip.pxi":4036
+ * 
+ *     def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0,
+ *                     maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False):             # <<<<<<<<<<<<<<
+ *         """Include a primal heuristic.
+ * 
+ */
+  __pyx_t_4 = PyTuple_New(6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4035, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_int_10000);
+  __Pyx_GIVEREF(__pyx_int_10000);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_int_10000)) __PYX_ERR(0, 4035, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_1)) __PYX_ERR(0, 4035, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_int_0)) __PYX_ERR(0, 4035, __pyx_L1_error);
+  __Pyx_INCREF(__pyx_int_neg_1);
+  __Pyx_GIVEREF(__pyx_int_neg_1);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_int_neg_1)) __PYX_ERR(0, 4035, __pyx_L1_error);
+  __Pyx_GIVEREF(__pyx_t_2);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 4, __pyx_t_2)) __PYX_ERR(0, 4035, __pyx_L1_error);
+  __Pyx_INCREF(Py_False);
+  __Pyx_GIVEREF(Py_False);
+  if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 5, Py_False)) __PYX_ERR(0, 4035, __pyx_L1_error);
+  __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":4035
+ *         Py_INCREF(prop)
+ * 
+ *     def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0,             # <<<<<<<<<<<<<<
+ *                     maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False):
+ *         """Include a primal heuristic.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_433includeHeur, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeHeur, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__956)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4035, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_t_4);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeHeur, __pyx_t_2) < 0) __PYX_ERR(0, 4035, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4064
+ *         Py_INCREF(heur)
+ * 
+ *     def includeRelax(self, Relax relax, name, desc, priority=10000, freq=1):             # <<<<<<<<<<<<<<
+ *         """Include a relaxation handler.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_435includeRelax, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeRelax, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__958)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4064, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__959);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeRelax, __pyx_t_2) < 0) __PYX_ERR(0, 4064, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4083
+ *         Py_INCREF(relax)
+ * 
+ *     def includeCutsel(self, Cutsel cutsel, name, desc, priority):             # <<<<<<<<<<<<<<
+ *         """include a cut selector
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_437includeCutsel, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeCutsel, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__961)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4083, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeCutsel, __pyx_t_2) < 0) __PYX_ERR(0, 4083, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4101
+ *         Py_INCREF(cutsel)
+ * 
+ *     def includeBranchrule(self, Branchrule branchrule, name, desc, priority, maxdepth, maxbounddist):             # <<<<<<<<<<<<<<
+ *         """Include a branching rule.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_439includeBranchrule, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeBranchrule, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__963)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeBranchrule, __pyx_t_2) < 0) __PYX_ERR(0, 4101, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4122
+ *         Py_INCREF(branchrule)
+ * 
+ *     def includeNodesel(self, Nodesel nodesel, name, desc, stdpriority, memsavepriority):             # <<<<<<<<<<<<<<
+ *         """Include a node selector.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_441includeNodesel, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeNodesel, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__965)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeNodesel, __pyx_t_2) < 0) __PYX_ERR(0, 4122, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4142
+ *         Py_INCREF(nodesel)
+ * 
+ *     def includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True,             # <<<<<<<<<<<<<<
+ *             shareaux=False):
+ *         """Include a Benders' decomposition.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_443includeBenders, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeBenders, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__967)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__968);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeBenders, __pyx_t_2) < 0) __PYX_ERR(0, 4142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4172
+ *         Py_INCREF(benders)
+ * 
+ *     def includeBenderscut(self, Benders benders, Benderscut benderscut, name, desc, priority=1, islpcut=True):             # <<<<<<<<<<<<<<
+ *         """ Include a Benders' decomposition cutting method
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_445includeBenderscut, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_includeBenderscut, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__970)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4172, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__940);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_includeBenderscut, __pyx_t_2) < 0) __PYX_ERR(0, 4172, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4203
+ * 
+ * 
+ *     def getLPBranchCands(self):             # <<<<<<<<<<<<<<
+ *         """gets branching candidates for LP solution branching (fractional variables) along with solution values,
+ *         fractionalities, and number of branching candidates; The number of branching candidates does NOT account
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_447getLPBranchCands, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getLPBranchCands, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__972)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4203, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getLPBranchCands, __pyx_t_2) < 0) __PYX_ERR(0, 4203, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4235
+ *                 [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars)
+ * 
+ *     def getPseudoBranchCands(self):             # <<<<<<<<<<<<<<
+ *         """gets branching candidates for pseudo solution branching (non-fixed variables)
+ *         along with the number of candidates.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_449getPseudoBranchCands, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getPseudoBranchCands, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__974)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getPseudoBranchCands, __pyx_t_2) < 0) __PYX_ERR(0, 4235, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4255
+ *         return ([Variable.create(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands)
+ * 
+ *     def branchVar(self, Variable variable):             # <<<<<<<<<<<<<<
+ *         """Branch on a non-continuous variable.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_451branchVar, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_branchVar, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__976)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_branchVar, __pyx_t_2) < 0) __PYX_ERR(0, 4255, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4271
+ * 
+ * 
+ *     def branchVarVal(self, variable, value):             # <<<<<<<<<<<<<<
+ *         """Branches on variable using a value which separates the domain of the variable.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_453branchVarVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_branchVarVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__978)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4271, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_branchVarVal, __pyx_t_2) < 0) __PYX_ERR(0, 4271, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4288
+ *         return Node.create(downchild), Node.create(eqchild), Node.create(upchild)
+ * 
+ *     def calcNodeselPriority(self, Variable variable, branchdir, targetvalue):             # <<<<<<<<<<<<<<
+ *         """calculates the node selection priority for moving the given variable's LP value
+ *         to the given target value;
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_455calcNodeselPriority, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_calcNodeselPriority, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__980)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4288, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_calcNodeselPriority, __pyx_t_2) < 0) __PYX_ERR(0, 4288, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4301
+ *         return SCIPcalcNodeselPriority(self._scip, variable.scip_var, branchdir, targetvalue)
+ * 
+ *     def calcChildEstimate(self, Variable variable, targetvalue):             # <<<<<<<<<<<<<<
+ *         """Calculates an estimate for the objective of the best feasible solution
+ *         contained in the subtree after applying the given branching;
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_457calcChildEstimate, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_calcChildEstimate, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__982)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4301, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_calcChildEstimate, __pyx_t_2) < 0) __PYX_ERR(0, 4301, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4313
+ *         return SCIPcalcChildEstimate(self._scip, variable.scip_var, targetvalue)
+ * 
+ *     def createChild(self, nodeselprio, estimate):             # <<<<<<<<<<<<<<
+ *         """Create a child node of the focus node.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_459createChild, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createChild, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__984)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4313, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createChild, __pyx_t_2) < 0) __PYX_ERR(0, 4313, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4326
+ * 
+ *     # Diving methods (Diving is LP related)
+ *     def startDive(self):             # <<<<<<<<<<<<<<
+ *         """Initiates LP diving
+ *         It allows the user to change the LP in several ways, solve, change again, etc, without affecting the actual LP that has. When endDive() is called,
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_461startDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_startDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__985)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4326, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_startDive, __pyx_t_2) < 0) __PYX_ERR(0, 4326, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4333
+ *         PY_SCIP_CALL(SCIPstartDive(self._scip))
+ * 
+ *     def endDive(self):             # <<<<<<<<<<<<<<
+ *         """Quits probing and resets bounds and constraints to the focus node's environment"""
+ *         PY_SCIP_CALL(SCIPendDive(self._scip))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_463endDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_endDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__986)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4333, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_endDive, __pyx_t_2) < 0) __PYX_ERR(0, 4333, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4337
+ *         PY_SCIP_CALL(SCIPendDive(self._scip))
+ * 
+ *     def chgVarObjDive(self, Variable var, newobj):             # <<<<<<<<<<<<<<
+ *         """changes (column) variable's objective value in current dive"""
+ *         PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_465chgVarObjDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarObjDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__988)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarObjDive, __pyx_t_2) < 0) __PYX_ERR(0, 4337, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4341
+ *         PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj))
+ * 
+ *     def chgVarLbDive(self, Variable var, newbound):             # <<<<<<<<<<<<<<
+ *         """changes variable's current lb in current dive"""
+ *         PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_467chgVarLbDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarLbDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__990)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarLbDive, __pyx_t_2) < 0) __PYX_ERR(0, 4341, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4345
+ *         PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound))
+ * 
+ *     def chgVarUbDive(self, Variable var, newbound):             # <<<<<<<<<<<<<<
+ *         """changes variable's current ub in current dive"""
+ *         PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_469chgVarUbDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarUbDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__991)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4345, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarUbDive, __pyx_t_2) < 0) __PYX_ERR(0, 4345, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4349
+ *         PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound))
+ * 
+ *     def getVarLbDive(self, Variable var):             # <<<<<<<<<<<<<<
+ *         """returns variable's current lb in current dive"""
+ *         return SCIPgetVarLbDive(self._scip, var.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_471getVarLbDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getVarLbDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__992)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4349, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getVarLbDive, __pyx_t_2) < 0) __PYX_ERR(0, 4349, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4353
+ *         return SCIPgetVarLbDive(self._scip, var.scip_var)
+ * 
+ *     def getVarUbDive(self, Variable var):             # <<<<<<<<<<<<<<
+ *         """returns variable's current ub in current dive"""
+ *         return SCIPgetVarUbDive(self._scip, var.scip_var)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_473getVarUbDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getVarUbDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__993)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4353, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getVarUbDive, __pyx_t_2) < 0) __PYX_ERR(0, 4353, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4357
+ *         return SCIPgetVarUbDive(self._scip, var.scip_var)
+ * 
+ *     def chgRowLhsDive(self, Row row, newlhs):             # <<<<<<<<<<<<<<
+ *         """changes row lhs in current dive, change will be undone after diving
+ *         ends, for permanent changes use SCIPchgRowLhs()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_475chgRowLhsDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgRowLhsDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__995)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4357, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgRowLhsDive, __pyx_t_2) < 0) __PYX_ERR(0, 4357, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4363
+ *         PY_SCIP_CALL(SCIPchgRowLhsDive(self._scip, row.scip_row, newlhs))
+ * 
+ *     def chgRowRhsDive(self, Row row, newrhs):             # <<<<<<<<<<<<<<
+ *         """changes row rhs in current dive, change will be undone after diving
+ *         ends, for permanent changes use SCIPchgRowLhs()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_477chgRowRhsDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgRowRhsDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__997)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4363, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgRowRhsDive, __pyx_t_2) < 0) __PYX_ERR(0, 4363, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4369
+ *         PY_SCIP_CALL(SCIPchgRowRhsDive(self._scip, row.scip_row, newrhs))
+ * 
+ *     def addRowDive(self, Row row):             # <<<<<<<<<<<<<<
+ *         """adds a row to the LP in current dive"""
+ *         PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_479addRowDive, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addRowDive, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__998)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4369, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addRowDive, __pyx_t_2) < 0) __PYX_ERR(0, 4369, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4373
+ *         PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row))
+ * 
+ *     def solveDiveLP(self, itlim = -1):             # <<<<<<<<<<<<<<
+ *         """solves the LP of the current dive no separation or pricing is applied
+ *         no separation or pricing is applied
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_481solveDiveLP, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_solveDiveLP, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1000)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4373, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1001);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_solveDiveLP, __pyx_t_2) < 0) __PYX_ERR(0, 4373, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4387
+ *         return lperror, cutoff
+ * 
+ *     def inRepropagation(self):             # <<<<<<<<<<<<<<
+ *         """returns if the current node is already solved and only propagated again."""
+ *         return SCIPinRepropagation(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_483inRepropagation, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_inRepropagation, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1002)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4387, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_inRepropagation, __pyx_t_2) < 0) __PYX_ERR(0, 4387, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4392
+ * 
+ *     # Probing methods (Probing is tree based)
+ *     def startProbing(self):             # <<<<<<<<<<<<<<
+ *         """Initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),
+ *            SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), SCIPsolveProbingLP(), etc available
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_485startProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_startProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1003)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4392, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_startProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4392, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4398
+ *         PY_SCIP_CALL( SCIPstartProbing(self._scip) )
+ * 
+ *     def endProbing(self):             # <<<<<<<<<<<<<<
+ *         """Quits probing and resets bounds and constraints to the focus node's environment"""
+ *         PY_SCIP_CALL( SCIPendProbing(self._scip) )
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_487endProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_endProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1004)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4398, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_endProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4398, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4402
+ *         PY_SCIP_CALL( SCIPendProbing(self._scip) )
+ * 
+ *     def newProbingNode(self):             # <<<<<<<<<<<<<<
+ *         """creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the
+ *         probing path with a call to backtrackProbing()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_489newProbingNode, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_newProbingNode, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1005)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4402, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_newProbingNode, __pyx_t_2) < 0) __PYX_ERR(0, 4402, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4408
+ *         PY_SCIP_CALL( SCIPnewProbingNode(self._scip) )
+ * 
+ *     def backtrackProbing(self, probingdepth):             # <<<<<<<<<<<<<<
+ *         """undoes all changes to the problem applied in probing up to the given probing depth
+ *         :param probingdepth: probing depth of the node in the probing path that should be reactivated
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_491backtrackProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_backtrackProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1007)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4408, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_backtrackProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4408, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4414
+ *         PY_SCIP_CALL( SCIPbacktrackProbing(self._scip, probingdepth) )
+ * 
+ *     def getProbingDepth(self):             # <<<<<<<<<<<<<<
+ *         """returns the current probing depth"""
+ *         return SCIPgetProbingDepth(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_493getProbingDepth, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getProbingDepth, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1008)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4414, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getProbingDepth, __pyx_t_2) < 0) __PYX_ERR(0, 4414, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4418
+ *         return SCIPgetProbingDepth(self._scip)
+ * 
+ *     def chgVarObjProbing(self, Variable var, newobj):             # <<<<<<<<<<<<<<
+ *         """changes (column) variable's objective value during probing mode"""
+ *         PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) )
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_495chgVarObjProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarObjProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1009)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4418, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarObjProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4418, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4422
+ *         PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) )
+ * 
+ *     def chgVarLbProbing(self, Variable var, lb):             # <<<<<<<<<<<<<<
+ *         """changes the variable lower bound during probing mode
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_497chgVarLbProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarLbProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1010)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarLbProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4422, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4432
+ *         PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb))
+ * 
+ *     def chgVarUbProbing(self, Variable var, ub):             # <<<<<<<<<<<<<<
+ *         """changes the variable upper bound during probing mode
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_499chgVarUbProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarUbProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1011)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4432, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarUbProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4432, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4442
+ *         PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub))
+ * 
+ *     def fixVarProbing(self, Variable var, fixedval):             # <<<<<<<<<<<<<<
+ *         """Fixes a variable at the current probing node."""
+ *         PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) )
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_501fixVarProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_fixVarProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1013)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4442, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_fixVarProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4442, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4446
+ *         PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) )
+ * 
+ *     def isObjChangedProbing(self):             # <<<<<<<<<<<<<<
+ *         """returns whether the objective function has changed during probing mode"""
+ *         return SCIPisObjChangedProbing(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_503isObjChangedProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_isObjChangedProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1014)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4446, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_isObjChangedProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4446, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4450
+ *         return SCIPisObjChangedProbing(self._scip)
+ * 
+ *     def inProbing(self):             # <<<<<<<<<<<<<<
+ *         """returns whether we are in probing mode; probing mode is activated via startProbing() and stopped via endProbing()"""
+ *         return SCIPinProbing(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_505inProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_inProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1015)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4450, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_inProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4450, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4454
+ *         return SCIPinProbing(self._scip)
+ * 
+ *     def solveProbingLP(self, itlim = -1):             # <<<<<<<<<<<<<<
+ *         """solves the LP at the current probing node (cannot be applied at preprocessing stage)
+ *         no separation or pricing is applied
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_507solveProbingLP, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_solveProbingLP, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1016)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4454, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1001);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_solveProbingLP, __pyx_t_2) < 0) __PYX_ERR(0, 4454, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4468
+ *         return lperror, cutoff
+ * 
+ *     def applyCutsProbing(self):             # <<<<<<<<<<<<<<
+ *         """applies the cuts in the separation storage to the LP and clears the storage afterwards;
+ *         this method can only be applied during probing; the user should resolve the probing LP afterwards
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_509applyCutsProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_applyCutsProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1017)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4468, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_applyCutsProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4468, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4480
+ *         return cutoff
+ * 
+ *     def propagateProbing(self, maxproprounds):             # <<<<<<<<<<<<<<
+ *         """applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
+ *         the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_511propagateProbing, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_propagateProbing, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1019)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4480, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_propagateProbing, __pyx_t_2) < 0) __PYX_ERR(0, 4480, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4496
+ *         return cutoff, ndomredsfound
+ * 
+ *     def interruptSolve(self):             # <<<<<<<<<<<<<<
+ *         """Interrupt the solving process as soon as possible."""
+ *         PY_SCIP_CALL(SCIPinterruptSolve(self._scip))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_513interruptSolve, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_interruptSolve, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1020)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4496, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_interruptSolve, __pyx_t_2) < 0) __PYX_ERR(0, 4496, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4500
+ *         PY_SCIP_CALL(SCIPinterruptSolve(self._scip))
+ * 
+ *     def restartSolve(self):             # <<<<<<<<<<<<<<
+ *         """Restarts the solving process as soon as possible."""
+ *         PY_SCIP_CALL(SCIPrestartSolve(self._scip))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_515restartSolve, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_restartSolve, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1021)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4500, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_restartSolve, __pyx_t_2) < 0) __PYX_ERR(0, 4500, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4506
+ *     # Solution functions
+ * 
+ *     def writeLP(self, filename="LP.lp"):             # <<<<<<<<<<<<<<
+ *         """writes current LP to a file
+ *         :param filename: file name (Default value = "LP.lp")
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_517writeLP, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeLP, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1023)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4506, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1024);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeLP, __pyx_t_2) < 0) __PYX_ERR(0, 4506, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4518
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def createSol(self, Heur heur = None):             # <<<<<<<<<<<<<<
+ *         """Create a new primal solution in the transformed space.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_519createSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1026)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4518, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createSol, __pyx_t_2) < 0) __PYX_ERR(0, 4518, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4536
+ *         return solution
+ * 
+ *     def createPartialSol(self, Heur heur = None):             # <<<<<<<<<<<<<<
+ *         """Create a partial primal solution, initialized to unknown values.
+ *         :param Heur heur: heuristic that found the solution (Default value = None)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_521createPartialSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createPartialSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1028)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4536, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createPartialSol, __pyx_t_2) < 0) __PYX_ERR(0, 4536, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4553
+ *         return partialsolution
+ * 
+ *     def createOrigSol(self, Heur heur = None):             # <<<<<<<<<<<<<<
+ *         """Create a new primal solution in the original space.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_523createOrigSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_createOrigSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1029)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4553, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_createOrigSol, __pyx_t_2) < 0) __PYX_ERR(0, 4553, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4572
+ *         return solution
+ * 
+ *     def printBestSol(self, write_zeros=False):             # <<<<<<<<<<<<<<
+ *         """Prints the best feasible primal solution."""
+ *         user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_525printBestSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_printBestSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1031)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4572, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__653);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_printBestSol, __pyx_t_2) < 0) __PYX_ERR(0, 4572, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4581
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def printSol(self, Solution solution=None, write_zeros=False):             # <<<<<<<<<<<<<<
+ *         """Print the given primal solution.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_527printSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_printSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1033)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4581, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1034);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_printSol, __pyx_t_2) < 0) __PYX_ERR(0, 4581, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4599
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def writeBestSol(self, filename="origprob.sol", write_zeros=False):             # <<<<<<<<<<<<<<
+ *         """Write the best feasible primal solution to a file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_529writeBestSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeBestSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1036)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4599, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1037);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeBestSol, __pyx_t_2) < 0) __PYX_ERR(0, 4599, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4618
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def writeBestTransSol(self, filename="transprob.sol", write_zeros=False):             # <<<<<<<<<<<<<<
+ *         """Write the best feasible primal solution for the transformed problem to a file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_531writeBestTransSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeBestTransSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1038)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4618, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1039);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeBestTransSol, __pyx_t_2) < 0) __PYX_ERR(0, 4618, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4636
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def writeSol(self, Solution solution, filename="origprob.sol", write_zeros=False):             # <<<<<<<<<<<<<<
+ *         """Write the given primal solution to a file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_533writeSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1041)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4636, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1037);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeSol, __pyx_t_2) < 0) __PYX_ERR(0, 4636, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4655
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def writeTransSol(self, Solution solution, filename="transprob.sol", write_zeros=False):             # <<<<<<<<<<<<<<
+ *         """Write the given transformed primal solution to a file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_535writeTransSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeTransSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1042)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4655, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1039);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeTransSol, __pyx_t_2) < 0) __PYX_ERR(0, 4655, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4676
+ *     # perhaps this should not be included as it implements duplicated functionality
+ *     #   (as does it's namesake in SCIP)
+ *     def readSol(self, filename):             # <<<<<<<<<<<<<<
+ *         """Reads a given solution file, problem has to be transformed in advance.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_537readSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_readSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1043)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4676, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_readSol, __pyx_t_2) < 0) __PYX_ERR(0, 4676, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4690
+ *         locale.setlocale(locale.LC_NUMERIC, user_locale)
+ * 
+ *     def readSolFile(self, filename):             # <<<<<<<<<<<<<<
+ *         """Reads a given solution file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_539readSolFile, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_readSolFile, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1045)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4690, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_readSolFile, __pyx_t_2) < 0) __PYX_ERR(0, 4690, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4720
+ *         return solution
+ * 
+ *     def setSolVal(self, Solution solution, Variable var, val):             # <<<<<<<<<<<<<<
+ *         """Set a variable in a solution.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_541setSolVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setSolVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1047)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4720, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setSolVal, __pyx_t_2) < 0) __PYX_ERR(0, 4720, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4734
+ *         PY_SCIP_CALL(SCIPsetSolVal(self._scip, _sol, var.scip_var, val))
+ * 
+ *     def trySol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, free=True):             # <<<<<<<<<<<<<<
+ *         """Check given primal solution for feasibility and try to add it to the storage.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_543trySol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_trySol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1049)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4734, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1050);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_trySol, __pyx_t_2) < 0) __PYX_ERR(0, 4734, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4753
+ *         return stored
+ * 
+ *     def checkSol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, original=False):             # <<<<<<<<<<<<<<
+ *         """Check given primal solution for feasibility without adding it to the storage.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_545checkSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_checkSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1052)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4753, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1053);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_checkSol, __pyx_t_2) < 0) __PYX_ERR(0, 4753, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4772
+ *         return feasible
+ * 
+ *     def addSol(self, Solution solution, free=True):             # <<<<<<<<<<<<<<
+ *         """Try to add a solution to the storage.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_547addSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_addSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1055)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4772, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_addSol, __pyx_t_2) < 0) __PYX_ERR(0, 4772, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4786
+ *         return stored
+ * 
+ *     def freeSol(self, Solution solution):             # <<<<<<<<<<<<<<
+ *         """Free given solution
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_549freeSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_freeSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1056)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4786, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_freeSol, __pyx_t_2) < 0) __PYX_ERR(0, 4786, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4794
+ *         PY_SCIP_CALL(SCIPfreeSol(self._scip, &solution.sol))
+ * 
+ *     def getNSols(self):             # <<<<<<<<<<<<<<
+ *         """gets number of feasible primal solutions stored in the solution storage in case the problem is transformed;
+ *            in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_551getNSols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNSols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1057)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4794, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNSols, __pyx_t_2) < 0) __PYX_ERR(0, 4794, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4801
+ *         return SCIPgetNSols(self._scip)
+ * 
+ *     def getNSolsFound(self):             # <<<<<<<<<<<<<<
+ *         """gets number of feasible primal solutions found so far"""
+ *         return SCIPgetNSolsFound(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_553getNSolsFound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNSolsFound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1058)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4801, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNSolsFound, __pyx_t_2) < 0) __PYX_ERR(0, 4801, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4805
+ *         return SCIPgetNSolsFound(self._scip)
+ * 
+ *     def getNLimSolsFound(self):             # <<<<<<<<<<<<<<
+ *         """gets number of feasible primal solutions respecting the objective limit found so far"""
+ *         return SCIPgetNLimSolsFound(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_555getNLimSolsFound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNLimSolsFound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1059)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4805, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNLimSolsFound, __pyx_t_2) < 0) __PYX_ERR(0, 4805, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4809
+ *         return SCIPgetNLimSolsFound(self._scip)
+ * 
+ *     def getNBestSolsFound(self):             # <<<<<<<<<<<<<<
+ *         """gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found"""
+ *         return SCIPgetNBestSolsFound(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_557getNBestSolsFound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNBestSolsFound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1060)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4809, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNBestSolsFound, __pyx_t_2) < 0) __PYX_ERR(0, 4809, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4813
+ *         return SCIPgetNBestSolsFound(self._scip)
+ * 
+ *     def getSols(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve list of all feasible primal solutions stored in the solution storage."""
+ *         cdef SCIP_SOL** _sols
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_559getSols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getSols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1062)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4813, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getSols, __pyx_t_2) < 0) __PYX_ERR(0, 4813, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4826
+ *         return sols
+ * 
+ *     def getBestSol(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve currently best known feasible primal solution."""
+ *         self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_561getBestSol, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getBestSol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1063)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4826, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getBestSol, __pyx_t_2) < 0) __PYX_ERR(0, 4826, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4831
+ *         return self._bestSol
+ * 
+ *     def getSolObjVal(self, Solution sol, original=True):             # <<<<<<<<<<<<<<
+ *         """Retrieve the objective value of the solution.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_563getSolObjVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getSolObjVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1065)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4831, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getSolObjVal, __pyx_t_2) < 0) __PYX_ERR(0, 4831, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4847
+ *         return objval
+ * 
+ *     def getSolTime(self, Solution sol):             # <<<<<<<<<<<<<<
+ *         """Get clock time, when this solution was found.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_565getSolTime, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getSolTime, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1067)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4847, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getSolTime, __pyx_t_2) < 0) __PYX_ERR(0, 4847, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4855
+ *         return SCIPgetSolTime(self._scip, sol.sol)
+ * 
+ *     def getObjVal(self, original=True):             # <<<<<<<<<<<<<<
+ *         """Retrieve the objective value of value of best solution.
+ *         Can only be called after solving is completed.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_567getObjVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getObjVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1068)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4855, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getObjVal, __pyx_t_2) < 0) __PYX_ERR(0, 4855, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4866
+ *         return self.getSolObjVal(self._bestSol, original)
+ * 
+ *     def getSolVal(self, Solution sol, Expr expr):             # <<<<<<<<<<<<<<
+ *         """Retrieve value of given variable or expression in the given solution or in
+ *         the LP/pseudo solution if sol == None
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_569getSolVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getSolVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1070)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4866, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getSolVal, __pyx_t_2) < 0) __PYX_ERR(0, 4866, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4883
+ *         return sol[expr]
+ * 
+ *     def getVal(self, Expr expr):             # <<<<<<<<<<<<<<
+ *         """Retrieve the value of the given variable or expression in the best known solution.
+ *         Can only be called after solving is completed.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_571getVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1072)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4883, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getVal, __pyx_t_2) < 0) __PYX_ERR(0, 4883, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4895
+ *         return self.getSolVal(self._bestSol, expr)
+ * 
+ *     def hasPrimalRay(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Returns whether a primal ray is stored that proves unboundedness of the LP relaxation
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_573hasPrimalRay, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_hasPrimalRay, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1073)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4895, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_hasPrimalRay, __pyx_t_2) < 0) __PYX_ERR(0, 4895, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4901
+ *         return SCIPhasPrimalRay(self._scip)
+ * 
+ *     def getPrimalRayVal(self, Variable var):             # <<<<<<<<<<<<<<
+ *         """
+ *         Gets value of given variable in primal ray causing unboundedness of the LP relaxation
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_575getPrimalRayVal, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getPrimalRayVal, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1074)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4901, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getPrimalRayVal, __pyx_t_2) < 0) __PYX_ERR(0, 4901, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4909
+ *         return SCIPgetPrimalRayVal(self._scip, var.scip_var)
+ * 
+ *     def getPrimalRay(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Gets primal ray causing unboundedness of the LP relaxation
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_577getPrimalRay, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getPrimalRay, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1076)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4909, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getPrimalRay, __pyx_t_2) < 0) __PYX_ERR(0, 4909, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4924
+ *         return ray
+ * 
+ *     def getPrimalbound(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the best primal bound."""
+ *         return SCIPgetPrimalbound(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_579getPrimalbound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getPrimalbound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1077)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4924, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getPrimalbound, __pyx_t_2) < 0) __PYX_ERR(0, 4924, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4928
+ *         return SCIPgetPrimalbound(self._scip)
+ * 
+ *     def getDualbound(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the best dual bound."""
+ *         return SCIPgetDualbound(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_581getDualbound, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getDualbound, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1078)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4928, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getDualbound, __pyx_t_2) < 0) __PYX_ERR(0, 4928, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4932
+ *         return SCIPgetDualbound(self._scip)
+ * 
+ *     def getDualboundRoot(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve the best root dual bound."""
+ *         return SCIPgetDualboundRoot(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_583getDualboundRoot, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getDualboundRoot, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1079)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4932, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getDualboundRoot, __pyx_t_2) < 0) __PYX_ERR(0, 4932, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4936
+ *         return SCIPgetDualboundRoot(self._scip)
+ * 
+ *     def writeName(self, Variable var):             # <<<<<<<<<<<<<<
+ *         """Write the name of the variable to the std out.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_585writeName, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeName, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1081)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4936, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeName, __pyx_t_2) < 0) __PYX_ERR(0, 4936, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4949
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def getStage(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve current SCIP stage"""
+ *         return SCIPgetStage(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_587getStage, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getStage, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1082)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4949, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getStage, __pyx_t_2) < 0) __PYX_ERR(0, 4949, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4953
+ *         return SCIPgetStage(self._scip)
+ * 
+ *     def getStageName(self):             # <<<<<<<<<<<<<<
+ *         """Returns name of current stage as string"""
+ *         if not StageNames:
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_589getStageName, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getStageName, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1083)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4953, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getStageName, __pyx_t_2) < 0) __PYX_ERR(0, 4953, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4959
+ *         return StageNames[self.getStage()]
+ * 
+ *     def _getStageNames(self):             # <<<<<<<<<<<<<<
+ *         """Gets names of stages"""
+ *         for name in dir(PY_SCIP_STAGE):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_591_getStageNames, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model__getStageNames, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1084)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4959, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getStageNames, __pyx_t_2) < 0) __PYX_ERR(0, 4959, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":4966
+ *                 StageNames[attr] = name
+ * 
+ *     def getStatus(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve solution status."""
+ *         cdef SCIP_STATUS stat = SCIPgetStatus(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_593getStatus, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getStatus, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1085)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4966, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getStatus, __pyx_t_2) < 0) __PYX_ERR(0, 4966, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5004
+ *             return "unknown"
+ * 
+ *     def getObjectiveSense(self):             # <<<<<<<<<<<<<<
+ *         """Retrieve objective sense."""
+ *         cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_595getObjectiveSense, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getObjectiveSense, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1087)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5004, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getObjectiveSense, __pyx_t_2) < 0) __PYX_ERR(0, 5004, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5014
+ *             return "unknown"
+ * 
+ *     def catchEvent(self, eventtype, Eventhdlr eventhdlr):             # <<<<<<<<<<<<<<
+ *         """catches a global (not variable or row dependent) event"""
+ *         cdef SCIP_EVENTHDLR* _eventhdlr
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_597catchEvent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_catchEvent, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1089)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5014, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_catchEvent, __pyx_t_2) < 0) __PYX_ERR(0, 5014, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5026
+ *         PY_SCIP_CALL(SCIPcatchEvent(self._scip, eventtype, _eventhdlr, NULL, NULL))
+ * 
+ *     def dropEvent(self, eventtype, Eventhdlr eventhdlr):             # <<<<<<<<<<<<<<
+ *         """drops a global event (stops to track event)"""
+ *         cdef SCIP_EVENTHDLR* _eventhdlr
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_599dropEvent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_dropEvent, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1090)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5026, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_dropEvent, __pyx_t_2) < 0) __PYX_ERR(0, 5026, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5038
+ *         PY_SCIP_CALL(SCIPdropEvent(self._scip, eventtype, _eventhdlr, NULL, -1))
+ * 
+ *     def catchVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr):             # <<<<<<<<<<<<<<
+ *         """catches an objective value or domain change event on the given transformed variable"""
+ *         cdef SCIP_EVENTHDLR* _eventhdlr
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_601catchVarEvent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_catchVarEvent, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1092)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5038, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_catchVarEvent, __pyx_t_2) < 0) __PYX_ERR(0, 5038, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5048
+ *         PY_SCIP_CALL(SCIPcatchVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, NULL))
+ * 
+ *     def dropVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr):             # <<<<<<<<<<<<<<
+ *         """drops an objective value or domain change event (stops to track event) on the given transformed variable"""
+ *         cdef SCIP_EVENTHDLR* _eventhdlr
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_603dropVarEvent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_dropVarEvent, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1093)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5048, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_dropVarEvent, __pyx_t_2) < 0) __PYX_ERR(0, 5048, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5058
+ *         PY_SCIP_CALL(SCIPdropVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, -1))
+ * 
+ *     def catchRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr):             # <<<<<<<<<<<<<<
+ *         """catches a row coefficient, constant, or side change event on the given row"""
+ *         cdef SCIP_EVENTHDLR* _eventhdlr
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_605catchRowEvent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_catchRowEvent, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1095)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5058, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_catchRowEvent, __pyx_t_2) < 0) __PYX_ERR(0, 5058, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5068
+ *         PY_SCIP_CALL(SCIPcatchRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, NULL))
+ * 
+ *     def dropRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr):             # <<<<<<<<<<<<<<
+ *         """drops a row coefficient, constant, or side change event (stops to track event) on the given row"""
+ *         cdef SCIP_EVENTHDLR* _eventhdlr
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_607dropRowEvent, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_dropRowEvent, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1096)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5068, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_dropRowEvent, __pyx_t_2) < 0) __PYX_ERR(0, 5068, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5080
+ *     # Statistic Methods
+ * 
+ *     def printStatistics(self):             # <<<<<<<<<<<<<<
+ *         """Print statistics."""
+ *         user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_609printStatistics, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_printStatistics, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1097)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5080, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_printStatistics, __pyx_t_2) < 0) __PYX_ERR(0, 5080, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5089
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def writeStatistics(self, filename="origprob.stats"):             # <<<<<<<<<<<<<<
+ *         """Write statistics to a file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_611writeStatistics, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeStatistics, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1099)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5089, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1100);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeStatistics, __pyx_t_2) < 0) __PYX_ERR(0, 5089, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5106
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def getNLPs(self):             # <<<<<<<<<<<<<<
+ *         """gets total number of LPs solved so far"""
+ *         return SCIPgetNLPs(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_613getNLPs, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNLPs, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1101)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNLPs, __pyx_t_2) < 0) __PYX_ERR(0, 5106, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5112
+ *     # Verbosity Methods
+ * 
+ *     def hideOutput(self, quiet = True):             # <<<<<<<<<<<<<<
+ *         """Hide the output.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_615hideOutput, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_hideOutput, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1103)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5112, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_hideOutput, __pyx_t_2) < 0) __PYX_ERR(0, 5112, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5122
+ *     # Output Methods
+ * 
+ *     def redirectOutput(self):             # <<<<<<<<<<<<<<
+ *         """Send output to python instead of terminal."""
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_617redirectOutput, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_redirectOutput, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1105)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5122, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_redirectOutput, __pyx_t_2) < 0) __PYX_ERR(0, 5122, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5131
+ *         SCIPmessageSetErrorPrinting(relayErrorMessage, NULL)
+ * 
+ *     def setLogfile(self, path):             # <<<<<<<<<<<<<<
+ *         """sets the log file name for the currently installed message handler
+ *         :param path: name of log file, or None (no log)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_619setLogfile, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setLogfile, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1107)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setLogfile, __pyx_t_2) < 0) __PYX_ERR(0, 5131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5143
+ *     # Parameter Methods
+ * 
+ *     def setBoolParam(self, name, value):             # <<<<<<<<<<<<<<
+ *         """Set a boolean-valued parameter.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_621setBoolParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setBoolParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1109)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setBoolParam, __pyx_t_2) < 0) __PYX_ERR(0, 5143, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5153
+ *         PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, value))
+ * 
+ *     def setIntParam(self, name, value):             # <<<<<<<<<<<<<<
+ *         """Set an int-valued parameter.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_623setIntParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setIntParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1110)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5153, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setIntParam, __pyx_t_2) < 0) __PYX_ERR(0, 5153, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5163
+ *         PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, value))
+ * 
+ *     def setLongintParam(self, name, value):             # <<<<<<<<<<<<<<
+ *         """Set a long-valued parameter.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_625setLongintParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setLongintParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1111)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setLongintParam, __pyx_t_2) < 0) __PYX_ERR(0, 5163, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5173
+ *         PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, value))
+ * 
+ *     def setRealParam(self, name, value):             # <<<<<<<<<<<<<<
+ *         """Set a real-valued parameter.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_627setRealParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setRealParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1112)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5173, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setRealParam, __pyx_t_2) < 0) __PYX_ERR(0, 5173, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5183
+ *         PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, value))
+ * 
+ *     def setCharParam(self, name, value):             # <<<<<<<<<<<<<<
+ *         """Set a char-valued parameter.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_629setCharParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setCharParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1113)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5183, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setCharParam, __pyx_t_2) < 0) __PYX_ERR(0, 5183, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5193
+ *         PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value)))
+ * 
+ *     def setStringParam(self, name, value):             # <<<<<<<<<<<<<<
+ *         """Set a string-valued parameter.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_631setStringParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setStringParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1115)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setStringParam, __pyx_t_2) < 0) __PYX_ERR(0, 5193, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5204
+ *         PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v))
+ * 
+ *     def setParam(self, name, value):             # <<<<<<<<<<<<<<
+ *         """Set a parameter with value in int, bool, real, long, char or str.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_633setParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1117)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setParam, __pyx_t_2) < 0) __PYX_ERR(0, 5204, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5235
+ * 
+ * 
+ *     def getParam(self, name):             # <<<<<<<<<<<<<<
+ *         """Get the value of a parameter of type
+ *         int, bool, real, long, char or str.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_635getParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1119)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getParam, __pyx_t_2) < 0) __PYX_ERR(0, 5235, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5264
+ *             return SCIPparamGetString(param).decode('utf-8')
+ * 
+ *     def getParams(self):             # <<<<<<<<<<<<<<
+ *         """Gets the values of all parameters as a dict mapping parameter names
+ *         to their values."""
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_637getParams, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getParams, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1121)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5264, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getParams, __pyx_t_2) < 0) __PYX_ERR(0, 5264, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5276
+ *         return result
+ * 
+ *     def setParams(self, params):             # <<<<<<<<<<<<<<
+ *         """Sets multiple parameters at once.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_639setParams, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setParams, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1123)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5276, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setParams, __pyx_t_2) < 0) __PYX_ERR(0, 5276, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5284
+ *           self.setParam(name, value)
+ * 
+ *     def readParams(self, file):             # <<<<<<<<<<<<<<
+ *         """Read an external parameter file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_641readParams, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_readParams, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1125)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5284, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_readParams, __pyx_t_2) < 0) __PYX_ERR(0, 5284, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5299
+ *         locale.setlocale(locale.LC_NUMERIC, user_locale)
+ * 
+ *     def writeParams(self, filename='param.set', comments=True, onlychanged=True, verbose=True):             # <<<<<<<<<<<<<<
+ *         """Write parameter settings to an external file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_643writeParams, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_writeParams, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1127)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5299, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1128);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_writeParams, __pyx_t_2) < 0) __PYX_ERR(0, 5299, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5319
+ *         locale.setlocale(locale.LC_NUMERIC,user_locale)
+ * 
+ *     def resetParam(self, name):             # <<<<<<<<<<<<<<
+ *         """Reset parameter setting to its default value
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_645resetParam, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_resetParam, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1129)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5319, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_resetParam, __pyx_t_2) < 0) __PYX_ERR(0, 5319, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5328
+ *         PY_SCIP_CALL(SCIPresetParam(self._scip, n))
+ * 
+ *     def resetParams(self):             # <<<<<<<<<<<<<<
+ *         """Reset parameter settings to their default values"""
+ *         PY_SCIP_CALL(SCIPresetParams(self._scip))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_647resetParams, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_resetParams, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1130)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5328, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_resetParams, __pyx_t_2) < 0) __PYX_ERR(0, 5328, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5332
+ *         PY_SCIP_CALL(SCIPresetParams(self._scip))
+ * 
+ *     def setEmphasis(self, paraemphasis, quiet = True):             # <<<<<<<<<<<<<<
+ *         """Set emphasis settings
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_649setEmphasis, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setEmphasis, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1132)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5332, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__77);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setEmphasis, __pyx_t_2) < 0) __PYX_ERR(0, 5332, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5341
+ *         PY_SCIP_CALL(SCIPsetEmphasis(self._scip, paraemphasis, quiet))
+ * 
+ *     def readProblem(self, filename, extension = None):             # <<<<<<<<<<<<<<
+ *         """Read a problem instance from an external file.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_651readProblem, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_readProblem, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1134)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__772);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_readProblem, __pyx_t_2) < 0) __PYX_ERR(0, 5341, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5362
+ *     # Counting functions
+ * 
+ *     def count(self):             # <<<<<<<<<<<<<<
+ *         """Counts the number of feasible points of problem."""
+ *         PY_SCIP_CALL(SCIPcount(self._scip))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_653count, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_count, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1135)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5362, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_count, __pyx_t_2) < 0) __PYX_ERR(0, 5362, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5366
+ *         PY_SCIP_CALL(SCIPcount(self._scip))
+ * 
+ *     def getNReaders(self):             # <<<<<<<<<<<<<<
+ *         """Get number of currently available readers."""
+ *         return SCIPgetNReaders(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_655getNReaders, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNReaders, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1136)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5366, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNReaders, __pyx_t_2) < 0) __PYX_ERR(0, 5366, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5370
+ *         return SCIPgetNReaders(self._scip)
+ * 
+ *     def getNCountedSols(self):             # <<<<<<<<<<<<<<
+ *         """Get number of feasible solution."""
+ *         cdef SCIP_Bool valid
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_657getNCountedSols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getNCountedSols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1138)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getNCountedSols, __pyx_t_2) < 0) __PYX_ERR(0, 5370, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5380
+ *         return nsols
+ * 
+ *     def setParamsCountsols(self):             # <<<<<<<<<<<<<<
+ *         """Sets SCIP parameters such that a valid counting process is possible."""
+ *         PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_659setParamsCountsols, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_setParamsCountsols, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1139)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5380, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_setParamsCountsols, __pyx_t_2) < 0) __PYX_ERR(0, 5380, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5384
+ *         PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip))
+ * 
+ *     def freeReoptSolve(self):             # <<<<<<<<<<<<<<
+ *         """Frees all solution process data and prepares for reoptimization"""
+ *         PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip))
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_661freeReoptSolve, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_freeReoptSolve, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1140)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5384, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_freeReoptSolve, __pyx_t_2) < 0) __PYX_ERR(0, 5384, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5388
+ *         PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip))
+ * 
+ *     def chgReoptObjective(self, coeffs, sense = 'minimize'):             # <<<<<<<<<<<<<<
+ *         """Establish the objective function as a linear expression.
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_663chgReoptObjective, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgReoptObjective, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1142)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5388, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_tuple__1143);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgReoptObjective, __pyx_t_2) < 0) __PYX_ERR(0, 5388, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5434
+ *         free(_coeffs)
+ * 
+ *     def chgVarBranchPriority(self, Variable var, priority):             # <<<<<<<<<<<<<<
+ *         """Sets the branch priority of the variable.
+ *         Variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable.
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_665chgVarBranchPriority, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_chgVarBranchPriority, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1145)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5434, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_chgVarBranchPriority, __pyx_t_2) < 0) __PYX_ERR(0, 5434, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "src/pyscipopt/scip.pxi":5444
+ *         PY_SCIP_CALL(SCIPchgVarBranchPriority(self._scip, var.scip_var, priority))
+ * 
+ *     def getTreesizeEstimation(self):             # <<<<<<<<<<<<<<
+ *         """Get an estimation of the final tree size """
+ *         return SCIPgetTreesizeEstimation(self._scip)
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_667getTreesizeEstimation, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model_getTreesizeEstimation, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1146)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5444, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_9pyscipopt_4scip_Model, __pyx_n_s_getTreesizeEstimation, __pyx_t_2) < 0) __PYX_ERR(0, 5444, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  PyType_Modified(__pyx_ptype_9pyscipopt_4scip_Model);
+
+  /* "(tree fragment)":1
+ * def __reduce_cython__(self):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_669__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model___reduce_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1147)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":3
+ * def __reduce_cython__(self):
+ *     raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling"
+ * def __setstate_cython__(self, __pyx_state):             # <<<<<<<<<<<<<<
+ *     raise TypeError, "self._scip,self._valid cannot be converted to a Python object for pickling"
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_5Model_671__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_Model___setstate_cython, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1148)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(6, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":5449
+ * 
+ * # debugging memory management
+ * def is_memory_freed():             # <<<<<<<<<<<<<<
+ *     return BMSgetMemoryUsed() == 0
+ * 
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_29is_memory_freed, 0, __pyx_n_s_is_memory_freed, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1149)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5449, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_memory_freed, __pyx_t_2) < 0) __PYX_ERR(0, 5449, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "src/pyscipopt/scip.pxi":5452
+ *     return BMSgetMemoryUsed() == 0
+ * 
+ * def print_memory_in_use():             # <<<<<<<<<<<<<<
+ *     BMScheckEmptyMemory()
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_31print_memory_in_use, 0, __pyx_n_s_print_memory_in_use, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1150)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5452, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_print_memory_in_use, __pyx_t_2) < 0) __PYX_ERR(0, 5452, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Expr(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_33__pyx_unpickle_Expr, 0, __pyx_n_s_pyx_unpickle_Expr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1152)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Expr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Expr__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Expr__set_state(Expr __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.terms = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_35__pyx_unpickle_ExprCons, 0, __pyx_n_s_pyx_unpickle_ExprCons, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1153)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_ExprCons, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_GenExpr(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_37__pyx_unpickle_GenExpr, 0, __pyx_n_s_pyx_unpickle_GenExpr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1154)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_GenExpr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_GenExpr__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_GenExpr__set_state(GenExpr __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]
+ *     if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_39__pyx_unpickle_SumExpr, 0, __pyx_n_s_pyx_unpickle_SumExpr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1155)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_SumExpr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_ProdExpr(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_41__pyx_unpickle_ProdExpr, 0, __pyx_n_s_pyx_unpickle_ProdExpr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1156)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_ProdExpr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_ProdExpr__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_ProdExpr__set_state(ProdExpr __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.constant = __pyx_state[2]
+ *     if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_43__pyx_unpickle_VarExpr, 0, __pyx_n_s_pyx_unpickle_VarExpr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1157)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_VarExpr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PowExpr(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_45__pyx_unpickle_PowExpr, 0, __pyx_n_s_pyx_unpickle_PowExpr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1158)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PowExpr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PowExpr__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PowExpr__set_state(PowExpr __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.expo = __pyx_state[2]
+ *     if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_47__pyx_unpickle_UnaryExpr, 0, __pyx_n_s_pyx_unpickle_UnaryExpr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1159)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_UnaryExpr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Constant(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_49__pyx_unpickle_Constant, 0, __pyx_n_s_pyx_unpickle_Constant, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1160)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Constant, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Constant__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Constant__set_state(Constant __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result._op = __pyx_state[0]; __pyx_result.children = __pyx_state[1]; __pyx_result.number = __pyx_state[2]
+ *     if len(__pyx_state) > 3 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_51__pyx_unpickle_Benderscut, 0, __pyx_n_s_pyx_unpickle_Benderscut, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1161)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Benderscut, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Branchrule(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_53__pyx_unpickle_Branchrule, 0, __pyx_n_s_pyx_unpickle_Branchrule, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1162)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Branchrule, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Branchrule__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Branchrule__set_state(Branchrule __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.model = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_55__pyx_unpickle_Conshdlr, 0, __pyx_n_s_pyx_unpickle_Conshdlr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1163)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Conshdlr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Cutsel(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_57__pyx_unpickle_Cutsel, 0, __pyx_n_s_pyx_unpickle_Cutsel, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1164)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Cutsel, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Cutsel__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Cutsel__set_state(Cutsel __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.model = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_59__pyx_unpickle_Eventhdlr, 0, __pyx_n_s_pyx_unpickle_Eventhdlr, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1165)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Eventhdlr, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Heur(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_61__pyx_unpickle_Heur, 0, __pyx_n_s_pyx_unpickle_Heur, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1166)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Heur, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Heur__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Heur__set_state(Heur __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1]
+ *     if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_63__pyx_unpickle_Presol, 0, __pyx_n_s_pyx_unpickle_Presol, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1167)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Presol, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Pricer(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_65__pyx_unpickle_Pricer, 0, __pyx_n_s_pyx_unpickle_Pricer, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1168)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Pricer, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Pricer__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Pricer__set_state(Pricer __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.model = __pyx_state[0]
+ *     if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_67__pyx_unpickle_Prop, 0, __pyx_n_s_pyx_unpickle_Prop, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1169)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Prop, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Sepa(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_69__pyx_unpickle_Sepa, 0, __pyx_n_s_pyx_unpickle_Sepa, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1170)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Sepa, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Sepa__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Sepa__set_state(Sepa __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1]
+ *     if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_71__pyx_unpickle_Reader, 0, __pyx_n_s_pyx_unpickle_Reader, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1171)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Reader, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_Relax(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_73__pyx_unpickle_Relax, 0, __pyx_n_s_pyx_unpickle_Relax, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1172)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Relax, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_Relax__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_Relax__set_state(Relax __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     __pyx_result.model = __pyx_state[0]; __pyx_result.name = __pyx_state[1]
+ *     if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'):
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_75__pyx_unpickle_Nodesel, 0, __pyx_n_s_pyx_unpickle_Nodesel, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1173)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Nodesel, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PY_SCIP_RESULT(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_79__pyx_unpickle_PY_SCIP_RESULT, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_RESULT, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1174)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_RESULT, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PY_SCIP_RESULT__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PY_SCIP_RESULT__set_state(PY_SCIP_RESULT __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[0])
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_81__pyx_unpickle_PY_SCIP_PARAMSETTING, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1175)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMSETT, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PY_SCIP_PARAMEMPHASIS(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_83__pyx_unpickle_PY_SCIP_PARAMEMPHASIS, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1176)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_PARAMEMPH, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PY_SCIP_PARAMEMPHASIS__set_state(PY_SCIP_PARAMEMPHASIS __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[0])
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_85__pyx_unpickle_PY_SCIP_STATUS, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_STATUS, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1177)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_STATUS, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PY_SCIP_STAGE(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_87__pyx_unpickle_PY_SCIP_STAGE, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_STAGE, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1178)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_STAGE, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PY_SCIP_STAGE__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PY_SCIP_STAGE__set_state(PY_SCIP_STAGE __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[0])
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_89__pyx_unpickle_PY_SCIP_NODETYPE, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1179)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_NODETYPE, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PY_SCIP_PROPTIMING(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_91__pyx_unpickle_PY_SCIP_PROPTIMING, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1180)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_PROPTIMIN, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PY_SCIP_PROPTIMING__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PY_SCIP_PROPTIMING__set_state(PY_SCIP_PROPTIMING __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[0])
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_93__pyx_unpickle_PY_SCIP_PRESOLTIMING, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1181)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_PRESOLTIM, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PY_SCIP_HEURTIMING(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_95__pyx_unpickle_PY_SCIP_HEURTIMING, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1182)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_HEURTIMIN, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PY_SCIP_HEURTIMING__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PY_SCIP_HEURTIMING__set_state(PY_SCIP_HEURTIMING __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[0])
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_97__pyx_unpickle_PY_SCIP_EVENTTYPE, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1183)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_EVENTTYPE, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PY_SCIP_LPSOLSTAT(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_99__pyx_unpickle_PY_SCIP_LPSOLSTAT, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1184)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_LPSOLSTAT, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PY_SCIP_LPSOLSTAT__set_state(PY_SCIP_LPSOLSTAT __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[0])
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_101__pyx_unpickle_PY_SCIP_BRANCHDIR, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1185)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_BRANCHDIR, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":1
+ * def __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE(__pyx_type, long __pyx_checksum, __pyx_state):             # <<<<<<<<<<<<<<
+ *     cdef object __pyx_PickleError
+ *     cdef object __pyx_result
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_103__pyx_unpickle_PY_SCIP_BENDERSENFOTYPE, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1186)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_BENDERSEN, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "(tree fragment)":11
+ *         __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state( __pyx_result, __pyx_state)
+ *     return __pyx_result
+ * cdef __pyx_unpickle_PY_SCIP_BENDERSENFOTYPE__set_state(PY_SCIP_BENDERSENFOTYPE __pyx_result, tuple __pyx_state):             # <<<<<<<<<<<<<<
+ *     if len(__pyx_state) > 0 and hasattr(__pyx_result, '__dict__'):
+ *         __pyx_result.__dict__.update(__pyx_state[0])
+ */
+  __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_9pyscipopt_4scip_105__pyx_unpickle_PY_SCIP_ROWORIGINTYPE, 0, __pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN, NULL, __pyx_n_s_pyscipopt_scip, __pyx_d, ((PyObject *)__pyx_codeobj__1187)); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_PY_SCIP_ROWORIGIN, __pyx_t_2) < 0) __PYX_ERR(6, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pyscipopt/scip.pyx":1
+ * # This redirection to scip.pxi is necessary to allow for code coverage to work             # <<<<<<<<<<<<<<
+ * # as it was producing syntax errors when parsing the .pyx file.
+ * include "scip.pxi"
+ */
+  __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(5, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  if (__pyx_m) {
+    if (__pyx_d && stringtab_initialized) {
+      __Pyx_AddTraceback("init pyscipopt.scip", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    #if !CYTHON_USE_MODULE_STATE
+    Py_CLEAR(__pyx_m);
+    #else
+    Py_DECREF(__pyx_m);
+    if (pystate_addmodule_run) {
+      PyObject *tp, *value, *tb;
+      PyErr_Fetch(&tp, &value, &tb);
+      PyState_RemoveModule(&__pyx_moduledef);
+      PyErr_Restore(tp, value, tb);
+    }
+    #endif
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init pyscipopt.scip");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if CYTHON_PEP489_MULTI_PHASE_INIT
+  return (__pyx_m != NULL) ? 0 : -1;
+  #elif PY_MAJOR_VERSION >= 3
+  return __pyx_m;
+  #else
+  return;
+  #endif
+}
+/* #### Code section: cleanup_globals ### */
+/* #### Code section: cleanup_module ### */
+/* #### Code section: main_method ### */
+/* #### Code section: utility_code_pragmas ### */
+#ifdef _MSC_VER
+#pragma warning( push )
+/* Warning 4127: conditional expression is constant
+ * Cython uses constant conditional expressions to allow in inline functions to be optimized at
+ * compile-time, so this warning is not useful
+ */
+#pragma warning( disable : 4127 )
+#endif
+
+
+
+/* #### Code section: utility_code_def ### */
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule(modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, "RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* PyErrExceptionMatches */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/* PyObjectGetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#endif
+
+/* PyObjectGetAttrStrNoError */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        __Pyx_PyErr_Clear();
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) {
+    PyObject *result;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    (void) PyObject_GetOptionalAttr(obj, attr_name, &result);
+    return result;
+#else
+#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) {
+        return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1);
+    }
+#endif
+    result = __Pyx_PyObject_GetAttrStr(obj, attr_name);
+    if (unlikely(!result)) {
+        __Pyx_PyObject_GetAttrStr_ClearAttributeError();
+    }
+    return result;
+#endif
+}
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name);
+    if (unlikely(!result) && !PyErr_Occurred()) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* TupleAndListFromArray */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
+    PyObject *v;
+    Py_ssize_t i;
+    for (i = 0; i < length; i++) {
+        v = dest[i] = src[i];
+        Py_INCREF(v);
+    }
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        Py_INCREF(__pyx_empty_tuple);
+        return __pyx_empty_tuple;
+    }
+    res = PyTuple_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n);
+    return res;
+}
+static CYTHON_INLINE PyObject *
+__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n)
+{
+    PyObject *res;
+    if (n <= 0) {
+        return PyList_New(0);
+    }
+    res = PyList_New(n);
+    if (unlikely(res == NULL)) return NULL;
+    __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n);
+    return res;
+}
+#endif
+
+/* BytesEquals */
+static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+    if (s1 == s2) {
+        return (equals == Py_EQ);
+    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
+        const char *ps1, *ps2;
+        Py_ssize_t length = PyBytes_GET_SIZE(s1);
+        if (length != PyBytes_GET_SIZE(s2))
+            return (equals == Py_NE);
+        ps1 = PyBytes_AS_STRING(s1);
+        ps2 = PyBytes_AS_STRING(s2);
+        if (ps1[0] != ps2[0]) {
+            return (equals == Py_NE);
+        } else if (length == 1) {
+            return (equals == Py_EQ);
+        } else {
+            int result;
+#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000)
+            Py_hash_t hash1, hash2;
+            hash1 = ((PyBytesObject*)s1)->ob_shash;
+            hash2 = ((PyBytesObject*)s2)->ob_shash;
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                return (equals == Py_NE);
+            }
+#endif
+            result = memcmp(ps1, ps2, (size_t)length);
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
+        return (equals == Py_NE);
+    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
+        return (equals == Py_NE);
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+#endif
+}
+
+/* UnicodeEquals */
+static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_RichCompareBool(s1, s2, equals);
+#else
+#if PY_MAJOR_VERSION < 3
+    PyObject* owned_ref = NULL;
+#endif
+    int s1_is_unicode, s2_is_unicode;
+    if (s1 == s2) {
+        goto return_eq;
+    }
+    s1_is_unicode = PyUnicode_CheckExact(s1);
+    s2_is_unicode = PyUnicode_CheckExact(s2);
+#if PY_MAJOR_VERSION < 3
+    if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) {
+        owned_ref = PyUnicode_FromObject(s2);
+        if (unlikely(!owned_ref))
+            return -1;
+        s2 = owned_ref;
+        s2_is_unicode = 1;
+    } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) {
+        owned_ref = PyUnicode_FromObject(s1);
+        if (unlikely(!owned_ref))
+            return -1;
+        s1 = owned_ref;
+        s1_is_unicode = 1;
+    } else if (((!s2_is_unicode) & (!s1_is_unicode))) {
+        return __Pyx_PyBytes_Equals(s1, s2, equals);
+    }
+#endif
+    if (s1_is_unicode & s2_is_unicode) {
+        Py_ssize_t length;
+        int kind;
+        void *data1, *data2;
+        if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0))
+            return -1;
+        length = __Pyx_PyUnicode_GET_LENGTH(s1);
+        if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) {
+            goto return_ne;
+        }
+#if CYTHON_USE_UNICODE_INTERNALS
+        {
+            Py_hash_t hash1, hash2;
+        #if CYTHON_PEP393_ENABLED
+            hash1 = ((PyASCIIObject*)s1)->hash;
+            hash2 = ((PyASCIIObject*)s2)->hash;
+        #else
+            hash1 = ((PyUnicodeObject*)s1)->hash;
+            hash2 = ((PyUnicodeObject*)s2)->hash;
+        #endif
+            if (hash1 != hash2 && hash1 != -1 && hash2 != -1) {
+                goto return_ne;
+            }
+        }
+#endif
+        kind = __Pyx_PyUnicode_KIND(s1);
+        if (kind != __Pyx_PyUnicode_KIND(s2)) {
+            goto return_ne;
+        }
+        data1 = __Pyx_PyUnicode_DATA(s1);
+        data2 = __Pyx_PyUnicode_DATA(s2);
+        if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) {
+            goto return_ne;
+        } else if (length == 1) {
+            goto return_eq;
+        } else {
+            int result = memcmp(data1, data2, (size_t)(length * kind));
+            #if PY_MAJOR_VERSION < 3
+            Py_XDECREF(owned_ref);
+            #endif
+            return (equals == Py_EQ) ? (result == 0) : (result != 0);
+        }
+    } else if ((s1 == Py_None) & s2_is_unicode) {
+        goto return_ne;
+    } else if ((s2 == Py_None) & s1_is_unicode) {
+        goto return_ne;
+    } else {
+        int result;
+        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
+        #if PY_MAJOR_VERSION < 3
+        Py_XDECREF(owned_ref);
+        #endif
+        if (!py_result)
+            return -1;
+        result = __Pyx_PyObject_IsTrue(py_result);
+        Py_DECREF(py_result);
+        return result;
+    }
+return_eq:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_EQ);
+return_ne:
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(owned_ref);
+    #endif
+    return (equals == Py_NE);
+#endif
+}
+
+/* fastcall */
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s)
+{
+    Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames);
+    for (i = 0; i < n; i++)
+    {
+        if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i];
+    }
+    for (i = 0; i < n; i++)
+    {
+        int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ);
+        if (unlikely(eq != 0)) {
+            if (unlikely(eq < 0)) return NULL;
+            return kwvalues[i];
+        }
+    }
+    return NULL;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) {
+    Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames);
+    PyObject *dict;
+    dict = PyDict_New();
+    if (unlikely(!dict))
+        return NULL;
+    for (i=0; i= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject *const *kwvalues,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds));
+    while (1) {
+        Py_XDECREF(key); key = NULL;
+        Py_XDECREF(value); value = NULL;
+        if (kwds_is_tuple) {
+            Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(kwds);
+#else
+            size = PyTuple_Size(kwds);
+            if (size < 0) goto bad;
+#endif
+            if (pos >= size) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            key = __Pyx_PySequence_ITEM(kwds, pos);
+            if (!key) goto bad;
+#elif CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kwds, pos);
+#else
+            key = PyTuple_GetItem(kwds, pos);
+            if (!key) goto bad;
+#endif
+            value = kwvalues[pos];
+            pos++;
+        }
+        else
+        {
+            if (!PyDict_Next(kwds, &pos, &key, &value)) break;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(key);
+#endif
+        }
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_INCREF(value);
+            Py_DECREF(key);
+#endif
+            key = NULL;
+            value = NULL;
+            continue;
+        }
+#if !CYTHON_AVOID_BORROWED_REFS
+        Py_INCREF(key);
+#endif
+        Py_INCREF(value);
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key)
+                );
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+#if CYTHON_AVOID_BORROWED_REFS
+                    value = NULL;
+#endif
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    Py_XDECREF(key);
+    Py_XDECREF(value);
+    return -1;
+}
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* PyObjectCall */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = Py_TYPE(func)->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyFunctionFastCall */
+#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = __Pyx_PyFrame_GetLocalsplus(f);
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) {
+        return NULL;
+    }
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) {
+        return NULL;
+    }
+    #endif
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, (int)nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif
+
+/* PyObjectCallMethO */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func);
+    self = __Pyx_CyOrPyCFunction_GET_SELF(func);
+    #if PY_MAJOR_VERSION < 3
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    #else
+    if (unlikely(Py_EnterRecursiveCall(" while calling a Python object")))
+        return NULL;
+    #endif
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectFastCall */
+#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API
+static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) {
+    PyObject *argstuple;
+    PyObject *result = 0;
+    size_t i;
+    argstuple = PyTuple_New((Py_ssize_t)nargs);
+    if (unlikely(!argstuple)) return NULL;
+    for (i = 0; i < nargs; i++) {
+        Py_INCREF(args[i]);
+        if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad;
+    }
+    result = __Pyx_PyObject_Call(func, argstuple, kwargs);
+  bad:
+    Py_DECREF(argstuple);
+    return result;
+}
+#endif
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) {
+    Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs);
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (nargs == 0 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS))
+            return __Pyx_PyObject_CallMethO(func, NULL);
+    }
+    else if (nargs == 1 && kwargs == NULL) {
+        if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O))
+            return __Pyx_PyObject_CallMethO(func, args[0]);
+    }
+#endif
+    #if PY_VERSION_HEX < 0x030800B1
+    #if CYTHON_FAST_PYCCALL
+    if (PyCFunction_Check(func)) {
+        if (kwargs) {
+            return _PyCFunction_FastCallDict(func, args, nargs, kwargs);
+        } else {
+            return _PyCFunction_FastCallKeywords(func, args, nargs, NULL);
+        }
+    }
+    #if PY_VERSION_HEX >= 0x030700A1
+    if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) {
+        return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL);
+    }
+    #endif
+    #endif
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs);
+    }
+    #endif
+    #endif
+    if (kwargs == NULL) {
+        #if CYTHON_VECTORCALL
+        #if PY_VERSION_HEX < 0x03090000
+        vectorcallfunc f = _PyVectorcall_Function(func);
+        #else
+        vectorcallfunc f = PyVectorcall_Function(func);
+        #endif
+        if (f) {
+            return f(func, args, (size_t)nargs, NULL);
+        }
+        #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL
+        if (__Pyx_CyFunction_CheckExact(func)) {
+            __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func);
+            if (f) return f(func, args, (size_t)nargs, NULL);
+        }
+        #endif
+    }
+    if (nargs == 0) {
+        return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs);
+    }
+    #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API
+    return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs);
+    #else
+    return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs);
+    #endif
+}
+
+/* PyObjectCallOneArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *args[2] = {NULL, arg};
+    return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* pybytes_as_double */
+static double __Pyx_SlowPyString_AsDouble(PyObject *obj) {
+    PyObject *float_value;
+#if PY_MAJOR_VERSION >= 3
+    float_value = PyFloat_FromString(obj);
+#else
+    float_value = PyFloat_FromString(obj, 0);
+#endif
+    if (likely(float_value)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        double value = PyFloat_AS_DOUBLE(float_value);
+#else
+        double value = PyFloat_AsDouble(float_value);
+#endif
+        Py_DECREF(float_value);
+        return value;
+    }
+    return (double)-1;
+}
+static const char* __Pyx__PyBytes_AsDouble_Copy(const char* start, char* buffer, Py_ssize_t length) {
+    int last_was_punctuation = 1;
+    Py_ssize_t i;
+    for (i=0; i < length; i++) {
+        char chr = start[i];
+        int is_punctuation = (chr == '_') | (chr == '.') | (chr == 'e') | (chr == 'E');
+        *buffer = chr;
+        buffer += (chr != '_');
+        if (unlikely(last_was_punctuation & is_punctuation)) goto parse_failure;
+        last_was_punctuation = is_punctuation;
+    }
+    if (unlikely(last_was_punctuation)) goto parse_failure;
+    *buffer = '\0';
+    return buffer;
+parse_failure:
+    return NULL;
+}
+static double __Pyx__PyBytes_AsDouble_inf_nan(const char* start, Py_ssize_t length) {
+    int matches = 1;
+    char sign = start[0];
+    int is_signed = (sign == '+') | (sign == '-');
+    start += is_signed;
+    length -= is_signed;
+    switch (start[0]) {
+        #ifdef Py_NAN
+        case 'n':
+        case 'N':
+            if (unlikely(length != 3)) goto parse_failure;
+            matches &= (start[1] == 'a' || start[1] == 'A');
+            matches &= (start[2] == 'n' || start[2] == 'N');
+            if (unlikely(!matches)) goto parse_failure;
+            return (sign == '-') ? -Py_NAN : Py_NAN;
+        #endif
+        case 'i':
+        case 'I':
+            if (unlikely(length < 3)) goto parse_failure;
+            matches &= (start[1] == 'n' || start[1] == 'N');
+            matches &= (start[2] == 'f' || start[2] == 'F');
+            if (likely(length == 3 && matches))
+                return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
+            if (unlikely(length != 8)) goto parse_failure;
+            matches &= (start[3] == 'i' || start[3] == 'I');
+            matches &= (start[4] == 'n' || start[4] == 'N');
+            matches &= (start[5] == 'i' || start[5] == 'I');
+            matches &= (start[6] == 't' || start[6] == 'T');
+            matches &= (start[7] == 'y' || start[7] == 'Y');
+            if (unlikely(!matches)) goto parse_failure;
+            return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
+        case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+            break;
+        default:
+            goto parse_failure;
+    }
+    return 0.0;
+parse_failure:
+    return -1.0;
+}
+static CYTHON_INLINE int __Pyx__PyBytes_AsDouble_IsSpace(char ch) {
+    return (ch == 0x20) | !((ch < 0x9) | (ch > 0xd));
+}
+CYTHON_UNUSED static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length) {
+    double value;
+    Py_ssize_t i, digits;
+    const char *last = start + length;
+    char *end;
+    while (__Pyx__PyBytes_AsDouble_IsSpace(*start))
+        start++;
+    while (start < last - 1 && __Pyx__PyBytes_AsDouble_IsSpace(last[-1]))
+        last--;
+    length = last - start;
+    if (unlikely(length <= 0)) goto fallback;
+    value = __Pyx__PyBytes_AsDouble_inf_nan(start, length);
+    if (unlikely(value == -1.0)) goto fallback;
+    if (value != 0.0) return value;
+    digits = 0;
+    for (i=0; i < length; digits += start[i++] != '_');
+    if (likely(digits == length)) {
+        value = PyOS_string_to_double(start, &end, NULL);
+    } else if (digits < 40) {
+        char number[40];
+        last = __Pyx__PyBytes_AsDouble_Copy(start, number, length);
+        if (unlikely(!last)) goto fallback;
+        value = PyOS_string_to_double(number, &end, NULL);
+    } else {
+        char *number = (char*) PyMem_Malloc((digits + 1) * sizeof(char));
+        if (unlikely(!number)) goto fallback;
+        last = __Pyx__PyBytes_AsDouble_Copy(start, number, length);
+        if (unlikely(!last)) {
+            PyMem_Free(number);
+            goto fallback;
+        }
+        value = PyOS_string_to_double(number, &end, NULL);
+        PyMem_Free(number);
+    }
+    if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) {
+        return value;
+    }
+fallback:
+    return __Pyx_SlowPyString_AsDouble(obj);
+}
+
+/* pyobject_as_double */
+static double __Pyx__PyObject_AsDouble(PyObject* obj) {
+    if (PyUnicode_CheckExact(obj)) {
+        return __Pyx_PyUnicode_AsDouble(obj);
+    } else if (PyBytes_CheckExact(obj)) {
+        return __Pyx_PyBytes_AsDouble(obj);
+    } else if (PyByteArray_CheckExact(obj)) {
+        return __Pyx_PyByteArray_AsDouble(obj);
+    } else {
+        PyObject* float_value;
+#if !CYTHON_USE_TYPE_SLOTS
+        float_value = PyNumber_Float(obj);  if ((0)) goto bad;
+        (void)__Pyx_PyObject_CallOneArg;
+#else
+        PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number;
+        if (likely(nb) && likely(nb->nb_float)) {
+            float_value = nb->nb_float(obj);
+            if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) {
+                __Pyx_TypeName float_value_type_name = __Pyx_PyType_GetName(Py_TYPE(float_value));
+                PyErr_Format(PyExc_TypeError,
+                    "__float__ returned non-float (type " __Pyx_FMT_TYPENAME ")",
+                    float_value_type_name);
+                __Pyx_DECREF_TypeName(float_value_type_name);
+                Py_DECREF(float_value);
+                goto bad;
+            }
+        } else {
+            float_value = __Pyx_PyObject_CallOneArg((PyObject*)&PyFloat_Type, obj);
+        }
+#endif
+        if (likely(float_value)) {
+            double value = PyFloat_AS_DOUBLE(float_value);
+            Py_DECREF(float_value);
+            return value;
+        }
+    }
+bad:
+    return (double)-1;
+}
+
+/* GetTopmostException */
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
+static _PyErr_StackItem *
+__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
+{
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
+           exc_info->previous_item != NULL)
+    {
+        exc_info = exc_info->previous_item;
+    }
+    return exc_info;
+}
+#endif
+
+/* SaveResetException */
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    *type = exc_info->exc_type;
+    *value = exc_info->exc_value;
+    *tb = exc_info->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #endif
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = type;
+    exc_info->exc_value = value;
+    exc_info->exc_traceback = tb;
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+  #endif
+}
+#endif
+
+/* GetException */
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
+#endif
+{
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+  #else
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+  #endif
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    #if CYTHON_USE_EXC_INFO_STACK
+    {
+        _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
+        tmp_type = exc_info->exc_type;
+        tmp_value = exc_info->exc_value;
+        tmp_tb = exc_info->exc_traceback;
+        exc_info->exc_type = local_type;
+        exc_info->exc_value = local_value;
+        exc_info->exc_traceback = local_tb;
+      #endif
+    }
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/* PyIntCompare */
+static CYTHON_INLINE int __Pyx_PyInt_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_UNUSED_VAR(inplace);
+    if (op1 == op2) {
+        return 1;
+    }
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long a = PyInt_AS_LONG(op1);
+        return (a == b);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        int unequal;
+        unsigned long uintval;
+        Py_ssize_t size = __Pyx_PyLong_DigitCount(op1);
+        const digit* digits = __Pyx_PyLong_Digits(op1);
+        if (intval == 0) {
+            return (__Pyx_PyLong_IsZero(op1) == 1);
+        } else if (intval < 0) {
+            if (__Pyx_PyLong_IsNonNeg(op1))
+                return 0;
+            intval = -intval;
+        } else {
+            if (__Pyx_PyLong_IsNeg(op1))
+                return 0;
+        }
+        uintval = (unsigned long) intval;
+#if PyLong_SHIFT * 4 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 4)) {
+            unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 3 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 3)) {
+            unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 2 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 2)) {
+            unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 1 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 1)) {
+            unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
+        return (unequal == 0);
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        double a = __pyx_PyFloat_AsDouble(op1);
+#else
+        double a = PyFloat_AS_DOUBLE(op1);
+#endif
+        return ((double)a == (double)b);
+    }
+    return __Pyx_PyObject_IsTrueAndDecref(
+        PyObject_RichCompare(op1, op2, Py_EQ));
+}
+
+/* PyDictVersioning */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0;
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) {
+    PyObject **dictptr = NULL;
+    Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset;
+    if (offset) {
+#if CYTHON_COMPILING_IN_CPYTHON
+        dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj);
+#else
+        dictptr = _PyObject_GetDictPtr(obj);
+#endif
+    }
+    return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0;
+}
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) {
+    PyObject *dict = Py_TYPE(obj)->tp_dict;
+    if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict)))
+        return 0;
+    return obj_dict_version == __Pyx_get_object_dict_version(obj);
+}
+#endif
+
+/* GetModuleGlobalName */
+#if CYTHON_USE_DICT_VERSIONS
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value)
+#else
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name)
+#endif
+{
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000
+    result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    } else if (unlikely(PyErr_Occurred())) {
+        return NULL;
+    }
+#elif CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(!__pyx_m)) {
+        return NULL;
+    }
+    result = PyObject_GetAttr(__pyx_m, name);
+    if (likely(result)) {
+        return result;
+    }
+#else
+    result = PyDict_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+#endif
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version)
+    if (likely(result)) {
+        return __Pyx_NewRef(result);
+    }
+    PyErr_Clear();
+#endif
+    return __Pyx_GetBuiltinName(name);
+}
+
+/* pynumber_float */
+static CYTHON_INLINE PyObject* __Pyx__PyNumber_Float(PyObject* obj) {
+    double val;
+    if (PyLong_CheckExact(obj)) {
+#if CYTHON_USE_PYLONG_INTERNALS
+        if (likely(__Pyx_PyLong_IsCompact(obj))) {
+            val = (double) __Pyx_PyLong_CompactValue(obj);
+            goto no_error;
+        }
+#endif
+        val = PyLong_AsDouble(obj);
+    } else if (PyUnicode_CheckExact(obj)) {
+        val = __Pyx_PyUnicode_AsDouble(obj);
+    } else if (PyBytes_CheckExact(obj)) {
+        val = __Pyx_PyBytes_AsDouble(obj);
+    } else if (PyByteArray_CheckExact(obj)) {
+        val = __Pyx_PyByteArray_AsDouble(obj);
+    } else {
+        return PyNumber_Float(obj);
+    }
+    if (unlikely(val == -1 && PyErr_Occurred())) {
+        return NULL;
+    }
+#if CYTHON_USE_PYLONG_INTERNALS
+no_error:
+#endif
+    return PyFloat_FromDouble(val);
+}
+
+/* RaiseException */
+#if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+    if (cause) {
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+      #if PY_VERSION_HEX >= 0x030C00A6
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
+        PyThreadState *tstate = __Pyx_PyThreadState_Current;
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+/* PyFloatBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyFloat_EqObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) {
+    const double b = floatval;
+    double a;
+    CYTHON_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    if (op1 == op2) {
+        Py_RETURN_TRUE;
+    }
+    if (likely(PyFloat_CheckExact(op1))) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        a = __pyx_PyFloat_AsDouble(op1);
+#else
+        a = PyFloat_AS_DOUBLE(op1);
+#endif
+        
+    } else
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        a = (double) PyInt_AS_LONG(op1);
+        
+    } else
+    #endif
+    if (likely(PyLong_CheckExact(op1))) {
+        #if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsZero(op1)) {
+            a = 0.0;
+            
+        } else if (__Pyx_PyLong_IsCompact(op1)) {
+            a = (double) __Pyx_PyLong_CompactValue(op1);
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(op1);
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
+            switch (size) {
+                case -2:
+                case 2:
+                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -2)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                case 3:
+                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -3)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                case 4:
+                    if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -4)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                default:
+        #endif
+                    return (
+                        PyFloat_Type.tp_richcompare(op2, op1, Py_EQ));
+        #if CYTHON_USE_PYLONG_INTERNALS
+            }
+        }
+        #endif
+    } else {
+        return (
+            PyObject_RichCompare(op1, op2, Py_EQ));
+    }
+        if (a == b) {
+            Py_RETURN_TRUE;
+        } else {
+            Py_RETURN_FALSE;
+        }
+}
+#endif
+
+/* RaiseUnboundLocalError */
+static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
+    PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
+}
+
+/* pep479 */
+static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) {
+    PyObject *exc, *val, *tb, *cur_exc;
+    __Pyx_PyThreadState_declare
+    #ifdef __Pyx_StopAsyncIteration_USED
+    int is_async_stopiteration = 0;
+    #endif
+    CYTHON_MAYBE_UNUSED_VAR(in_async_gen);
+    cur_exc = PyErr_Occurred();
+    if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) {
+        #ifdef __Pyx_StopAsyncIteration_USED
+        if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, __Pyx_PyExc_StopAsyncIteration))) {
+            is_async_stopiteration = 1;
+        } else
+        #endif
+            return;
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_GetException(&exc, &val, &tb);
+    Py_XDECREF(exc);
+    Py_XDECREF(val);
+    Py_XDECREF(tb);
+    PyErr_SetString(PyExc_RuntimeError,
+        #ifdef __Pyx_StopAsyncIteration_USED
+        is_async_stopiteration ? "async generator raised StopAsyncIteration" :
+        in_async_gen ? "async generator raised StopIteration" :
+        #endif
+        "generator raised StopIteration");
+}
+
+/* FixUpExtensionType */
+#if CYTHON_USE_TYPE_SPECS
+static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) {
+#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    CYTHON_UNUSED_VAR(spec);
+    CYTHON_UNUSED_VAR(type);
+#else
+    const PyType_Slot *slot = spec->slots;
+    while (slot && slot->slot && slot->slot != Py_tp_members)
+        slot++;
+    if (slot && slot->slot == Py_tp_members) {
+        int changed = 0;
+#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON)
+        const
+#endif
+            PyMemberDef *memb = (PyMemberDef*) slot->pfunc;
+        while (memb && memb->name) {
+            if (memb->name[0] == '_' && memb->name[1] == '_') {
+#if PY_VERSION_HEX < 0x030900b1
+                if (strcmp(memb->name, "__weaklistoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_weaklistoffset = memb->offset;
+                    changed = 1;
+                }
+                else if (strcmp(memb->name, "__dictoffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+                    type->tp_dictoffset = memb->offset;
+                    changed = 1;
+                }
+#if CYTHON_METH_FASTCALL
+                else if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
+                    assert(memb->type == T_PYSSIZET);
+                    assert(memb->flags == READONLY);
+#if PY_VERSION_HEX >= 0x030800b4
+                    type->tp_vectorcall_offset = memb->offset;
+#else
+                    type->tp_print = (printfunc) memb->offset;
+#endif
+                    changed = 1;
+                }
+#endif
+#else
+                if ((0));
+#endif
+#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON
+                else if (strcmp(memb->name, "__module__") == 0) {
+                    PyObject *descr;
+                    assert(memb->type == T_OBJECT);
+                    assert(memb->flags == 0 || memb->flags == READONLY);
+                    descr = PyDescr_NewMember(type, memb);
+                    if (unlikely(!descr))
+                        return -1;
+                    if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) {
+                        Py_DECREF(descr);
+                        return -1;
+                    }
+                    Py_DECREF(descr);
+                    changed = 1;
+                }
+#endif
+            }
+            memb++;
+        }
+        if (changed)
+            PyType_Modified(type);
+    }
+#endif
+    return 0;
+}
+#endif
+
+/* FetchSharedCythonModule */
+static PyObject *__Pyx_FetchSharedCythonABIModule(void) {
+    return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME);
+}
+
+/* FetchCommonType */
+static int __Pyx_VerifyCachedType(PyObject *cached_type,
+                               const char *name,
+                               Py_ssize_t basicsize,
+                               Py_ssize_t expected_basicsize) {
+    if (!PyType_Check(cached_type)) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s is not a type object", name);
+        return -1;
+    }
+    if (basicsize != expected_basicsize) {
+        PyErr_Format(PyExc_TypeError,
+            "Shared Cython type %.200s has the wrong size, try recompiling",
+            name);
+        return -1;
+    }
+    return 0;
+}
+#if !CYTHON_USE_TYPE_SPECS
+static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+    PyObject* abi_module;
+    const char* object_name;
+    PyTypeObject *cached_type = NULL;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    object_name = strrchr(type->tp_name, '.');
+    object_name = object_name ? object_name+1 : type->tp_name;
+    cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        if (__Pyx_VerifyCachedType(
+              (PyObject *)cached_type,
+              object_name,
+              cached_type->tp_basicsize,
+              type->tp_basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    if (PyType_Ready(type) < 0) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0)
+        goto bad;
+    Py_INCREF(type);
+    cached_type = type;
+done:
+    Py_DECREF(abi_module);
+    return cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#else
+static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) {
+    PyObject *abi_module, *cached_type = NULL;
+    const char* object_name = strrchr(spec->name, '.');
+    object_name = object_name ? object_name+1 : spec->name;
+    abi_module = __Pyx_FetchSharedCythonABIModule();
+    if (!abi_module) return NULL;
+    cached_type = PyObject_GetAttrString(abi_module, object_name);
+    if (cached_type) {
+        Py_ssize_t basicsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        PyObject *py_basicsize;
+        py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__");
+        if (unlikely(!py_basicsize)) goto bad;
+        basicsize = PyLong_AsSsize_t(py_basicsize);
+        Py_DECREF(py_basicsize);
+        py_basicsize = 0;
+        if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+#else
+        basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1;
+#endif
+        if (__Pyx_VerifyCachedType(
+              cached_type,
+              object_name,
+              basicsize,
+              spec->basicsize) < 0) {
+            goto bad;
+        }
+        goto done;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
+    PyErr_Clear();
+    CYTHON_UNUSED_VAR(module);
+    cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases);
+    if (unlikely(!cached_type)) goto bad;
+    if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad;
+    if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad;
+done:
+    Py_DECREF(abi_module);
+    assert(cached_type == NULL || PyType_Check(cached_type));
+    return (PyTypeObject *) cached_type;
+bad:
+    Py_XDECREF(cached_type);
+    cached_type = NULL;
+    goto done;
+}
+#endif
+
+/* PyVectorcallFastCallDict */
+#if CYTHON_METH_FASTCALL
+static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    PyObject *res = NULL;
+    PyObject *kwnames;
+    PyObject **newargs;
+    PyObject **kwvalues;
+    Py_ssize_t i, pos;
+    size_t j;
+    PyObject *key, *value;
+    unsigned long keys_are_strings;
+    Py_ssize_t nkw = PyDict_GET_SIZE(kw);
+    newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0]));
+    if (unlikely(newargs == NULL)) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    for (j = 0; j < nargs; j++) newargs[j] = args[j];
+    kwnames = PyTuple_New(nkw);
+    if (unlikely(kwnames == NULL)) {
+        PyMem_Free(newargs);
+        return NULL;
+    }
+    kwvalues = newargs + nargs;
+    pos = i = 0;
+    keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS;
+    while (PyDict_Next(kw, &pos, &key, &value)) {
+        keys_are_strings &= Py_TYPE(key)->tp_flags;
+        Py_INCREF(key);
+        Py_INCREF(value);
+        PyTuple_SET_ITEM(kwnames, i, key);
+        kwvalues[i] = value;
+        i++;
+    }
+    if (unlikely(!keys_are_strings)) {
+        PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+        goto cleanup;
+    }
+    res = vc(func, newargs, nargs, kwnames);
+cleanup:
+    Py_DECREF(kwnames);
+    for (i = 0; i < nkw; i++)
+        Py_DECREF(kwvalues[i]);
+    PyMem_Free(newargs);
+    return res;
+}
+static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw)
+{
+    if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) {
+        return vc(func, args, nargs, NULL);
+    }
+    return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw);
+}
+#endif
+
+/* CythonFunctionShared */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    if (__Pyx_CyFunction_Check(func)) {
+        return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc;
+    } else if (PyCFunction_Check(func)) {
+        return PyCFunction_GetFunction(func) == (PyCFunction) cfunc;
+    }
+    return 0;
+}
+#else
+static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) {
+    return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc;
+}
+#endif
+static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) {
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    __Pyx_Py_XDECREF_SET(
+        __Pyx_CyFunction_GetClassObj(f),
+            ((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#else
+    __Pyx_Py_XDECREF_SET(
+        ((PyCMethodObject *) (f))->mm_class,
+        (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL));
+#endif
+}
+static PyObject *
+__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure)
+{
+    CYTHON_UNUSED_VAR(closure);
+    if (unlikely(op->func_doc == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_doc = PyObject_GetAttrString(op->func, "__doc__");
+        if (unlikely(!op->func_doc)) return NULL;
+#else
+        if (((PyCFunctionObject*)op)->m_ml->ml_doc) {
+#if PY_MAJOR_VERSION >= 3
+            op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#else
+            op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc);
+#endif
+            if (unlikely(op->func_doc == NULL))
+                return NULL;
+        } else {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+#endif
+    }
+    Py_INCREF(op->func_doc);
+    return op->func_doc;
+}
+static int
+__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (value == NULL) {
+        value = Py_None;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_doc, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_name == NULL)) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        op->func_name = PyObject_GetAttrString(op->func, "__name__");
+#elif PY_MAJOR_VERSION >= 3
+        op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#else
+        op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name);
+#endif
+        if (unlikely(op->func_name == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_name);
+    return op->func_name;
+}
+static int
+__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_qualname);
+    return op->func_qualname;
+}
+static int
+__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(op->func_dict == NULL)) {
+        op->func_dict = PyDict_New();
+        if (unlikely(op->func_dict == NULL))
+            return NULL;
+    }
+    Py_INCREF(op->func_dict);
+    return op->func_dict;
+}
+static int
+__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(value == NULL)) {
+        PyErr_SetString(PyExc_TypeError,
+               "function's dictionary may not be deleted");
+        return -1;
+    }
+    if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+               "setting function's dictionary to a non-dict");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_dict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(op->func_globals);
+    return op->func_globals;
+}
+static PyObject *
+__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context)
+{
+    CYTHON_UNUSED_VAR(op);
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+static PyObject *
+__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context)
+{
+    PyObject* result = (op->func_code) ? op->func_code : Py_None;
+    CYTHON_UNUSED_VAR(context);
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
+    int result = 0;
+    PyObject *res = op->defaults_getter((PyObject *) op);
+    if (unlikely(!res))
+        return -1;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
+    Py_INCREF(op->defaults_tuple);
+    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
+    Py_INCREF(op->defaults_kwdict);
+    #else
+    op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0);
+    if (unlikely(!op->defaults_tuple)) result = -1;
+    else {
+        op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1);
+        if (unlikely(!op->defaults_kwdict)) result = -1;
+    }
+    #endif
+    Py_DECREF(res);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyTuple_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__defaults__ must be set to a tuple object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_tuple, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_tuple;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_tuple;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value) {
+        value = Py_None;
+    } else if (unlikely(value != Py_None && !PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__kwdefaults__ must be set to a dict object");
+        return -1;
+    }
+    PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not "
+                 "currently affect the values used in function calls", 1);
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->defaults_kwdict;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        if (op->defaults_getter) {
+            if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL;
+            result = op->defaults_kwdict;
+        } else {
+            result = Py_None;
+        }
+    }
+    Py_INCREF(result);
+    return result;
+}
+static int
+__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    if (!value || value == Py_None) {
+        value = NULL;
+    } else if (unlikely(!PyDict_Check(value))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "__annotations__ must be set to a dict object");
+        return -1;
+    }
+    Py_XINCREF(value);
+    __Pyx_Py_XDECREF_SET(op->func_annotations, value);
+    return 0;
+}
+static PyObject *
+__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) {
+    PyObject* result = op->func_annotations;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!result)) {
+        result = PyDict_New();
+        if (unlikely(!result)) return NULL;
+        op->func_annotations = result;
+    }
+    Py_INCREF(result);
+    return result;
+}
+static PyObject *
+__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) {
+    int is_coroutine;
+    CYTHON_UNUSED_VAR(context);
+    if (op->func_is_coroutine) {
+        return __Pyx_NewRef(op->func_is_coroutine);
+    }
+    is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE;
+#if PY_VERSION_HEX >= 0x03050000
+    if (is_coroutine) {
+        PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine;
+        fromlist = PyList_New(1);
+        if (unlikely(!fromlist)) return NULL;
+        Py_INCREF(marker);
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyList_SET_ITEM(fromlist, 0, marker);
+#else
+        if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) {
+            Py_DECREF(marker);
+            Py_DECREF(fromlist);
+            return NULL;
+        }
+#endif
+        module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0);
+        Py_DECREF(fromlist);
+        if (unlikely(!module)) goto ignore;
+        op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker);
+        Py_DECREF(module);
+        if (likely(op->func_is_coroutine)) {
+            return __Pyx_NewRef(op->func_is_coroutine);
+        }
+ignore:
+        PyErr_Clear();
+    }
+#endif
+    op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine);
+    return __Pyx_NewRef(op->func_is_coroutine);
+}
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *
+__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_GetAttrString(op->func, "__module__");
+}
+static int
+__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) {
+    CYTHON_UNUSED_VAR(context);
+    return PyObject_SetAttrString(op->func, "__module__", value);
+}
+#endif
+static PyGetSetDef __pyx_CyFunction_getsets[] = {
+    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
+    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
+    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
+    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
+    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
+    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
+    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
+    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
+    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
+    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
+    {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0},
+#if CYTHON_COMPILING_IN_LIMITED_API
+    {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyMemberDef __pyx_CyFunction_members[] = {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0},
+#endif
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0},
+#if CYTHON_METH_FASTCALL
+#if CYTHON_BACKPORT_VECTORCALL
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0},
+#else
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0},
+#endif
+#endif
+#endif
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0},
+#else
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0},
+#endif
+#endif
+    {0, 0, 0,  0, 0}
+};
+static PyObject *
+__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args)
+{
+    CYTHON_UNUSED_VAR(args);
+#if PY_MAJOR_VERSION >= 3
+    Py_INCREF(m->func_qualname);
+    return m->func_qualname;
+#else
+    return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name);
+#endif
+}
+static PyMethodDef __pyx_CyFunction_methods[] = {
+    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
+    {0, 0, 0, 0}
+};
+#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
+#else
+#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist)
+#endif
+static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname,
+                                       PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    PyCFunctionObject *cf = (PyCFunctionObject*) op;
+#endif
+    if (unlikely(op == NULL))
+        return NULL;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    op->func = PyCFunction_NewEx(ml, (PyObject*)op, module);
+    if (unlikely(!op->func)) return NULL;
+#endif
+    op->flags = flags;
+    __Pyx_CyFunction_weakreflist(op) = NULL;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    cf->m_ml = ml;
+    cf->m_self = (PyObject *) op;
+#endif
+    Py_XINCREF(closure);
+    op->func_closure = closure;
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_XINCREF(module);
+    cf->m_module = module;
+#endif
+    op->func_dict = NULL;
+    op->func_name = NULL;
+    Py_INCREF(qualname);
+    op->func_qualname = qualname;
+    op->func_doc = NULL;
+#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API
+    op->func_classobj = NULL;
+#else
+    ((PyCMethodObject*)op)->mm_class = NULL;
+#endif
+    op->func_globals = globals;
+    Py_INCREF(op->func_globals);
+    Py_XINCREF(code);
+    op->func_code = code;
+    op->defaults_pyobjects = 0;
+    op->defaults_size = 0;
+    op->defaults = NULL;
+    op->defaults_tuple = NULL;
+    op->defaults_kwdict = NULL;
+    op->defaults_getter = NULL;
+    op->func_annotations = NULL;
+    op->func_is_coroutine = NULL;
+#if CYTHON_METH_FASTCALL
+    switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) {
+    case METH_NOARGS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS;
+        break;
+    case METH_O:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O;
+        break;
+    case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD;
+        break;
+    case METH_FASTCALL | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS;
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        __Pyx_CyFunction_func_vectorcall(op) = NULL;
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        Py_DECREF(op);
+        return NULL;
+    }
+#endif
+    return (PyObject *) op;
+}
+static int
+__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
+{
+    Py_CLEAR(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_CLEAR(m->func);
+#else
+    Py_CLEAR(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_CLEAR(m->func_dict);
+    Py_CLEAR(m->func_name);
+    Py_CLEAR(m->func_qualname);
+    Py_CLEAR(m->func_doc);
+    Py_CLEAR(m->func_globals);
+    Py_CLEAR(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX < 0x030900B1
+    Py_CLEAR(__Pyx_CyFunction_GetClassObj(m));
+#else
+    {
+        PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class;
+        ((PyCMethodObject *) (m))->mm_class = NULL;
+        Py_XDECREF(cls);
+    }
+#endif
+#endif
+    Py_CLEAR(m->defaults_tuple);
+    Py_CLEAR(m->defaults_kwdict);
+    Py_CLEAR(m->func_annotations);
+    Py_CLEAR(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_XDECREF(pydefaults[i]);
+        PyObject_Free(m->defaults);
+        m->defaults = NULL;
+    }
+    return 0;
+}
+static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    if (__Pyx_CyFunction_weakreflist(m) != NULL)
+        PyObject_ClearWeakRefs((PyObject *) m);
+    __Pyx_CyFunction_clear(m);
+    __Pyx_PyHeapTypeObject_GC_Del(m);
+}
+static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
+{
+    PyObject_GC_UnTrack(m);
+    __Pyx__CyFunction_dealloc(m);
+}
+static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
+{
+    Py_VISIT(m->func_closure);
+#if CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(m->func);
+#else
+    Py_VISIT(((PyCFunctionObject*)m)->m_module);
+#endif
+    Py_VISIT(m->func_dict);
+    Py_VISIT(m->func_name);
+    Py_VISIT(m->func_qualname);
+    Py_VISIT(m->func_doc);
+    Py_VISIT(m->func_globals);
+    Py_VISIT(m->func_code);
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    Py_VISIT(__Pyx_CyFunction_GetClassObj(m));
+#endif
+    Py_VISIT(m->defaults_tuple);
+    Py_VISIT(m->defaults_kwdict);
+    Py_VISIT(m->func_is_coroutine);
+    if (m->defaults) {
+        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
+        int i;
+        for (i = 0; i < m->defaults_pyobjects; i++)
+            Py_VISIT(pydefaults[i]);
+    }
+    return 0;
+}
+static PyObject*
+__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
+{
+#if PY_MAJOR_VERSION >= 3
+    return PyUnicode_FromFormat("",
+                                op->func_qualname, (void *)op);
+#else
+    return PyString_FromFormat("",
+                               PyString_AsString(op->func_qualname), (void *)op);
+#endif
+}
+static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *f = ((__pyx_CyFunctionObject*)func)->func;
+    PyObject *py_name = NULL;
+    PyCFunction meth;
+    int flags;
+    meth = PyCFunction_GetFunction(f);
+    if (unlikely(!meth)) return NULL;
+    flags = PyCFunction_GetFlags(f);
+    if (unlikely(flags < 0)) return NULL;
+#else
+    PyCFunctionObject* f = (PyCFunctionObject*)func;
+    PyCFunction meth = f->m_ml->ml_meth;
+    int flags = f->m_ml->ml_flags;
+#endif
+    Py_ssize_t size;
+    switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
+    case METH_VARARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0))
+            return (*meth)(self, arg);
+        break;
+    case METH_VARARGS | METH_KEYWORDS:
+        return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw);
+    case METH_NOARGS:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 0))
+                return (*meth)(self, NULL);
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    case METH_O:
+        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            size = PyTuple_GET_SIZE(arg);
+#else
+            size = PyTuple_Size(arg);
+            if (unlikely(size < 0)) return NULL;
+#endif
+            if (likely(size == 1)) {
+                PyObject *result, *arg0;
+                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                arg0 = PyTuple_GET_ITEM(arg, 0);
+                #else
+                arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
+                #endif
+                result = (*meth)(self, arg0);
+                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+                Py_DECREF(arg0);
+                #endif
+                return result;
+            }
+#if CYTHON_COMPILING_IN_LIMITED_API
+            py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+            if (!py_name) return NULL;
+            PyErr_Format(PyExc_TypeError,
+                "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                py_name, size);
+            Py_DECREF(py_name);
+#else
+            PyErr_Format(PyExc_TypeError,
+                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                f->m_ml->ml_name, size);
+#endif
+            return NULL;
+        }
+        break;
+    default:
+        PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction");
+        return NULL;
+    }
+#if CYTHON_COMPILING_IN_LIMITED_API
+    py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL);
+    if (!py_name) return NULL;
+    PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments",
+                 py_name);
+    Py_DECREF(py_name);
+#else
+    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
+                 f->m_ml->ml_name);
+#endif
+    return NULL;
+}
+static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *self, *result;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func);
+    if (unlikely(!self) && PyErr_Occurred()) return NULL;
+#else
+    self = ((PyCFunctionObject*)func)->m_self;
+#endif
+    result = __Pyx_CyFunction_CallMethod(func, self, arg, kw);
+    return result;
+}
+static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
+    PyObject *result;
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
+#if CYTHON_METH_FASTCALL
+     __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc);
+    if (vc) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw);
+#else
+        (void) &__Pyx_PyVectorcall_FastCallDict;
+        return PyVectorcall_Call(func, args, kw);
+#endif
+    }
+#endif
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        Py_ssize_t argc;
+        PyObject *new_args;
+        PyObject *self;
+#if CYTHON_ASSUME_SAFE_MACROS
+        argc = PyTuple_GET_SIZE(args);
+#else
+        argc = PyTuple_Size(args);
+        if (unlikely(!argc) < 0) return NULL;
+#endif
+        new_args = PyTuple_GetSlice(args, 1, argc);
+        if (unlikely(!new_args))
+            return NULL;
+        self = PyTuple_GetItem(args, 0);
+        if (unlikely(!self)) {
+            Py_DECREF(new_args);
+#if PY_MAJOR_VERSION > 2
+            PyErr_Format(PyExc_TypeError,
+                         "unbound method %.200S() needs an argument",
+                         cyfunc->func_qualname);
+#else
+            PyErr_SetString(PyExc_TypeError,
+                            "unbound method needs an argument");
+#endif
+            return NULL;
+        }
+        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
+        Py_DECREF(new_args);
+    } else {
+        result = __Pyx_CyFunction_Call(func, args, kw);
+    }
+    return result;
+}
+#if CYTHON_METH_FASTCALL
+static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames)
+{
+    int ret = 0;
+    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
+        if (unlikely(nargs < 1)) {
+            PyErr_Format(PyExc_TypeError, "%.200s() needs an argument",
+                         ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+            return -1;
+        }
+        ret = 1;
+    }
+    if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) {
+        PyErr_Format(PyExc_TypeError,
+                     "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name);
+        return -1;
+    }
+    return ret;
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 0)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, NULL);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    if (unlikely(nargs != 1)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
+            def->ml_name, nargs);
+        return NULL;
+    }
+    return def->ml_meth(self, args[0]);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames);
+}
+static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func;
+    PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml;
+    PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc);
+#if CYTHON_BACKPORT_VECTORCALL
+    Py_ssize_t nargs = (Py_ssize_t)nargsf;
+#else
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+#endif
+    PyObject *self;
+    switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) {
+    case 1:
+        self = args[0];
+        args += 1;
+        nargs -= 1;
+        break;
+    case 0:
+        self = ((PyCFunctionObject*)cyfunc)->m_self;
+        break;
+    default:
+        return NULL;
+    }
+    return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames);
+}
+#endif
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_CyFunctionType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc},
+    {Py_tp_repr, (void *)__Pyx_CyFunction_repr},
+    {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod},
+    {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse},
+    {Py_tp_clear, (void *)__Pyx_CyFunction_clear},
+    {Py_tp_methods, (void *)__pyx_CyFunction_methods},
+    {Py_tp_members, (void *)__pyx_CyFunction_members},
+    {Py_tp_getset, (void *)__pyx_CyFunction_getsets},
+    {Py_tp_descr_get, (void *)__Pyx_PyMethod_New},
+    {0, 0},
+};
+static PyType_Spec __pyx_CyFunctionType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL)
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    __pyx_CyFunctionType_slots
+};
+#else
+static PyTypeObject __pyx_CyFunctionType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "cython_function_or_method",
+    sizeof(__pyx_CyFunctionObject),
+    0,
+    (destructor) __Pyx_CyFunction_dealloc,
+#if !CYTHON_METH_FASTCALL
+    0,
+#elif CYTHON_BACKPORT_VECTORCALL
+    (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall),
+#else
+    offsetof(PyCFunctionObject, vectorcall),
+#endif
+    0,
+    0,
+#if PY_MAJOR_VERSION < 3
+    0,
+#else
+    0,
+#endif
+    (reprfunc) __Pyx_CyFunction_repr,
+    0,
+    0,
+    0,
+    0,
+    __Pyx_CyFunction_CallAsMethod,
+    0,
+    0,
+    0,
+    0,
+#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR
+    Py_TPFLAGS_METHOD_DESCRIPTOR |
+#endif
+#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL
+    _Py_TPFLAGS_HAVE_VECTORCALL |
+#endif
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+    0,
+    (traverseproc) __Pyx_CyFunction_traverse,
+    (inquiry) __Pyx_CyFunction_clear,
+    0,
+#if PY_VERSION_HEX < 0x030500A0
+    offsetof(__pyx_CyFunctionObject, func_weakreflist),
+#else
+    offsetof(PyCFunctionObject, m_weakreflist),
+#endif
+    0,
+    0,
+    __pyx_CyFunction_methods,
+    __pyx_CyFunction_members,
+    __pyx_CyFunction_getsets,
+    0,
+    0,
+    __Pyx_PyMethod_New,
+    0,
+    offsetof(__pyx_CyFunctionObject, func_dict),
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_CyFunction_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
+#endif
+    if (unlikely(__pyx_CyFunctionType == NULL)) {
+        return -1;
+    }
+    return 0;
+}
+static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults = PyObject_Malloc(size);
+    if (unlikely(!m->defaults))
+        return PyErr_NoMemory();
+    memset(m->defaults, 0, size);
+    m->defaults_pyobjects = pyobjects;
+    m->defaults_size = size;
+    return m->defaults;
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_tuple = tuple;
+    Py_INCREF(tuple);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->defaults_kwdict = dict;
+    Py_INCREF(dict);
+}
+static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
+    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
+    m->func_annotations = dict;
+    Py_INCREF(dict);
+}
+
+/* CythonFunction */
+static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
+                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
+    PyObject *op = __Pyx_CyFunction_Init(
+        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
+        ml, flags, qualname, closure, module, globals, code
+    );
+    if (likely(op)) {
+        PyObject_GC_Track(op);
+    }
+    return op;
+}
+
+/* PyObjectSetAttrStr */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_setattro))
+        return tp->tp_setattro(obj, attr_name, value);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_setattr))
+        return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
+#endif
+    return PyObject_SetAttr(obj, attr_name, value);
+}
+#endif
+
+/* GetItemInt */
+static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
+    PyObject *r;
+    if (unlikely(!j)) return NULL;
+    r = PyObject_GetItem(o, j);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    Py_ssize_t wrapped_i = i;
+    if (wraparound & unlikely(i < 0)) {
+        wrapped_i += PyList_GET_SIZE(o);
+    }
+    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) {
+        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    Py_ssize_t wrapped_i = i;
+    if (wraparound & unlikely(i < 0)) {
+        wrapped_i += PyTuple_GET_SIZE(o);
+    }
+    if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) {
+        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
+                                                     CYTHON_NCP_UNUSED int wraparound,
+                                                     CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
+        if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) {
+            PyObject *r = PyList_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    }
+    else if (PyTuple_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) {
+            PyObject *r = PyTuple_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    } else {
+        PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping;
+        PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence;
+        if (mm && mm->mp_subscript) {
+            PyObject *r, *key = PyInt_FromSsize_t(i);
+            if (unlikely(!key)) return NULL;
+            r = mm->mp_subscript(o, key);
+            Py_DECREF(key);
+            return r;
+        }
+        if (likely(sm && sm->sq_item)) {
+            if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) {
+                Py_ssize_t l = sm->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return NULL;
+                    PyErr_Clear();
+                }
+            }
+            return sm->sq_item(o, i);
+        }
+    }
+#else
+    if (is_list || !PyMapping_Check(o)) {
+        return PySequence_GetItem(o, i);
+    }
+#endif
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+}
+
+/* ObjectGetItem */
+#if CYTHON_USE_TYPE_SLOTS
+static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) {
+    PyObject *runerr = NULL;
+    Py_ssize_t key_value;
+    key_value = __Pyx_PyIndex_AsSsize_t(index);
+    if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) {
+        return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1);
+    }
+    if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) {
+        __Pyx_TypeName index_type_name = __Pyx_PyType_GetName(Py_TYPE(index));
+        PyErr_Clear();
+        PyErr_Format(PyExc_IndexError,
+            "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name);
+        __Pyx_DECREF_TypeName(index_type_name);
+    }
+    return NULL;
+}
+static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) {
+    __Pyx_TypeName obj_type_name;
+    if (likely(PyType_Check(obj))) {
+        PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_n_s_class_getitem);
+        if (!meth) {
+            PyErr_Clear();
+        } else {
+            PyObject *result = __Pyx_PyObject_CallOneArg(meth, key);
+            Py_DECREF(meth);
+            return result;
+        }
+    }
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return NULL;
+}
+static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) {
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyMappingMethods *mm = tp->tp_as_mapping;
+    PySequenceMethods *sm = tp->tp_as_sequence;
+    if (likely(mm && mm->mp_subscript)) {
+        return mm->mp_subscript(obj, key);
+    }
+    if (likely(sm && sm->sq_item)) {
+        return __Pyx_PyObject_GetIndex(obj, key);
+    }
+    return __Pyx_PyObject_GetItem_Slow(obj, key);
+}
+#endif
+
+/* PyObjectCallNoArg */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+    PyObject *arg[2] = {NULL, NULL};
+    return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* IterFinish */
+static CYTHON_INLINE int __Pyx_IterFinish(void) {
+    PyObject* exc_type;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    exc_type = __Pyx_PyErr_CurrentExceptionType();
+    if (unlikely(exc_type)) {
+        if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
+            return -1;
+        __Pyx_PyErr_Clear();
+        return 0;
+    }
+    return 0;
+}
+
+/* PyObjectGetMethod */
+static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) {
+    PyObject *attr;
+#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP
+    __Pyx_TypeName type_name;
+    PyTypeObject *tp = Py_TYPE(obj);
+    PyObject *descr;
+    descrgetfunc f = NULL;
+    PyObject **dictptr, *dict;
+    int meth_found = 0;
+    assert (*method == NULL);
+    if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) {
+        attr = __Pyx_PyObject_GetAttrStr(obj, name);
+        goto try_unpack;
+    }
+    if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) {
+        return 0;
+    }
+    descr = _PyType_Lookup(tp, name);
+    if (likely(descr != NULL)) {
+        Py_INCREF(descr);
+#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR
+        if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR))
+#elif PY_MAJOR_VERSION >= 3
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type)))
+        #endif
+#else
+        #ifdef __Pyx_CyFunction_USED
+        if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr)))
+        #else
+        if (likely(PyFunction_Check(descr)))
+        #endif
+#endif
+        {
+            meth_found = 1;
+        } else {
+            f = Py_TYPE(descr)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(descr)) {
+                attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+                Py_DECREF(descr);
+                goto try_unpack;
+            }
+        }
+    }
+    dictptr = _PyObject_GetDictPtr(obj);
+    if (dictptr != NULL && (dict = *dictptr) != NULL) {
+        Py_INCREF(dict);
+        attr = __Pyx_PyDict_GetItemStr(dict, name);
+        if (attr != NULL) {
+            Py_INCREF(attr);
+            Py_DECREF(dict);
+            Py_XDECREF(descr);
+            goto try_unpack;
+        }
+        Py_DECREF(dict);
+    }
+    if (meth_found) {
+        *method = descr;
+        return 1;
+    }
+    if (f != NULL) {
+        attr = f(descr, obj, (PyObject *)Py_TYPE(obj));
+        Py_DECREF(descr);
+        goto try_unpack;
+    }
+    if (likely(descr != NULL)) {
+        *method = descr;
+        return 0;
+    }
+    type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+#else
+    attr = __Pyx_PyObject_GetAttrStr(obj, name);
+    goto try_unpack;
+#endif
+try_unpack:
+#if CYTHON_UNPACK_METHODS
+    if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) {
+        PyObject *function = PyMethod_GET_FUNCTION(attr);
+        Py_INCREF(function);
+        Py_DECREF(attr);
+        *method = function;
+        return 1;
+    }
+#endif
+    *method = attr;
+    return 0;
+}
+
+/* PyObjectCallMethod0 */
+static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+    PyObject *method = NULL, *result = NULL;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_CallOneArg(method, obj);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) goto bad;
+    result = __Pyx_PyObject_CallNoArg(method);
+    Py_DECREF(method);
+bad:
+    return result;
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* RaiseTooManyValuesToUnpack */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* UnpackItemEndCheck */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
+    if (unlikely(retval)) {
+        Py_DECREF(retval);
+        __Pyx_RaiseTooManyValuesError(expected);
+        return -1;
+    }
+    return __Pyx_IterFinish();
+}
+
+/* RaiseNoneIterError */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* UnpackTupleError */
+static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
+    if (t == Py_None) {
+      __Pyx_RaiseNoneNotIterableError();
+    } else if (PyTuple_GET_SIZE(t) < index) {
+      __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
+    } else {
+      __Pyx_RaiseTooManyValuesError(index);
+    }
+}
+
+/* UnpackTuple2 */
+static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
+        PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) {
+    PyObject *value1 = NULL, *value2 = NULL;
+#if CYTHON_COMPILING_IN_PYPY
+    value1 = PySequence_ITEM(tuple, 0);  if (unlikely(!value1)) goto bad;
+    value2 = PySequence_ITEM(tuple, 1);  if (unlikely(!value2)) goto bad;
+#else
+    value1 = PyTuple_GET_ITEM(tuple, 0);  Py_INCREF(value1);
+    value2 = PyTuple_GET_ITEM(tuple, 1);  Py_INCREF(value2);
+#endif
+    if (decref_tuple) {
+        Py_DECREF(tuple);
+    }
+    *pvalue1 = value1;
+    *pvalue2 = value2;
+    return 0;
+#if CYTHON_COMPILING_IN_PYPY
+bad:
+    Py_XDECREF(value1);
+    Py_XDECREF(value2);
+    if (decref_tuple) { Py_XDECREF(tuple); }
+    return -1;
+#endif
+}
+static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
+                                       int has_known_size, int decref_tuple) {
+    Py_ssize_t index;
+    PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
+    iternextfunc iternext;
+    iter = PyObject_GetIter(tuple);
+    if (unlikely(!iter)) goto bad;
+    if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
+    iternext = __Pyx_PyObject_GetIterNextFunc(iter);
+    value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
+    value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
+    if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
+    Py_DECREF(iter);
+    *pvalue1 = value1;
+    *pvalue2 = value2;
+    return 0;
+unpacking_failed:
+    if (!has_known_size && __Pyx_IterFinish() == 0)
+        __Pyx_RaiseNeedMoreValuesError(index);
+bad:
+    Py_XDECREF(iter);
+    Py_XDECREF(value1);
+    Py_XDECREF(value2);
+    if (decref_tuple) { Py_XDECREF(tuple); }
+    return -1;
+}
+
+/* dict_iter */
+#if CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+#include 
+#endif
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_source_is_dict) {
+    is_dict = is_dict || likely(PyDict_CheckExact(iterable));
+    *p_source_is_dict = is_dict;
+    if (is_dict) {
+#if !CYTHON_COMPILING_IN_PYPY
+        *p_orig_length = PyDict_Size(iterable);
+        Py_INCREF(iterable);
+        return iterable;
+#elif PY_MAJOR_VERSION >= 3
+        static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL;
+        PyObject **pp = NULL;
+        if (method_name) {
+            const char *name = PyUnicode_AsUTF8(method_name);
+            if (strcmp(name, "iteritems") == 0) pp = &py_items;
+            else if (strcmp(name, "iterkeys") == 0) pp = &py_keys;
+            else if (strcmp(name, "itervalues") == 0) pp = &py_values;
+            if (pp) {
+                if (!*pp) {
+                    *pp = PyUnicode_FromString(name + 4);
+                    if (!*pp)
+                        return NULL;
+                }
+                method_name = *pp;
+            }
+        }
+#endif
+    }
+    *p_orig_length = 0;
+    if (method_name) {
+        PyObject* iter;
+        iterable = __Pyx_PyObject_CallMethod0(iterable, method_name);
+        if (!iterable)
+            return NULL;
+#if !CYTHON_COMPILING_IN_PYPY
+        if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable))
+            return iterable;
+#endif
+        iter = PyObject_GetIter(iterable);
+        Py_DECREF(iterable);
+        return iter;
+    }
+    return PyObject_GetIter(iterable);
+}
+static CYTHON_INLINE int __Pyx_dict_iter_next(
+        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
+        PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) {
+    PyObject* next_item;
+#if !CYTHON_COMPILING_IN_PYPY
+    if (source_is_dict) {
+        PyObject *key, *value;
+        if (unlikely(orig_length != PyDict_Size(iter_obj))) {
+            PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
+            return -1;
+        }
+        if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
+            return 0;
+        }
+        if (pitem) {
+            PyObject* tuple = PyTuple_New(2);
+            if (unlikely(!tuple)) {
+                return -1;
+            }
+            Py_INCREF(key);
+            Py_INCREF(value);
+            PyTuple_SET_ITEM(tuple, 0, key);
+            PyTuple_SET_ITEM(tuple, 1, value);
+            *pitem = tuple;
+        } else {
+            if (pkey) {
+                Py_INCREF(key);
+                *pkey = key;
+            }
+            if (pvalue) {
+                Py_INCREF(value);
+                *pvalue = value;
+            }
+        }
+        return 1;
+    } else if (PyTuple_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0;
+        *ppos = pos + 1;
+        next_item = PyTuple_GET_ITEM(iter_obj, pos);
+        Py_INCREF(next_item);
+    } else if (PyList_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0;
+        *ppos = pos + 1;
+        next_item = PyList_GET_ITEM(iter_obj, pos);
+        Py_INCREF(next_item);
+    } else
+#endif
+    {
+        next_item = PyIter_Next(iter_obj);
+        if (unlikely(!next_item)) {
+            return __Pyx_IterFinish();
+        }
+    }
+    if (pitem) {
+        *pitem = next_item;
+    } else if (pkey && pvalue) {
+        if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1))
+            return -1;
+    } else if (pkey) {
+        *pkey = next_item;
+    } else {
+        *pvalue = next_item;
+    }
+    return 1;
+}
+
+/* IterNext */
+static PyObject *__Pyx_PyIter_Next2Default(PyObject* defval) {
+    PyObject* exc_type;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    exc_type = __Pyx_PyErr_CurrentExceptionType();
+    if (unlikely(exc_type)) {
+        if (!defval || unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))
+            return NULL;
+        __Pyx_PyErr_Clear();
+        Py_INCREF(defval);
+        return defval;
+    }
+    if (defval) {
+        Py_INCREF(defval);
+        return defval;
+    }
+    __Pyx_PyErr_SetNone(PyExc_StopIteration);
+    return NULL;
+}
+static void __Pyx_PyIter_Next_ErrorNoIterator(PyObject *iterator) {
+    __Pyx_TypeName iterator_type_name = __Pyx_PyType_GetName(Py_TYPE(iterator));
+    PyErr_Format(PyExc_TypeError,
+        __Pyx_FMT_TYPENAME " object is not an iterator", iterator_type_name);
+    __Pyx_DECREF_TypeName(iterator_type_name);
+}
+static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) {
+    PyObject* next;
+    iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
+    if (likely(iternext)) {
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+        next = iternext(iterator);
+        if (likely(next))
+            return next;
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000
+        if (unlikely(iternext == &_PyObject_NextNotImplemented))
+            return NULL;
+#endif
+#else
+        next = PyIter_Next(iterator);
+        if (likely(next))
+            return next;
+#endif
+    } else if (CYTHON_USE_TYPE_SLOTS || unlikely(!PyIter_Check(iterator))) {
+        __Pyx_PyIter_Next_ErrorNoIterator(iterator);
+        return NULL;
+    }
+#if !CYTHON_USE_TYPE_SLOTS
+    else {
+        next = PyIter_Next(iterator);
+        if (likely(next))
+            return next;
+    }
+#endif
+    return __Pyx_PyIter_Next2Default(defval);
+}
+
+/* py_abs */
+#if CYTHON_USE_PYLONG_INTERNALS
+static PyObject *__Pyx_PyLong_AbsNeg(PyObject *n) {
+#if PY_VERSION_HEX >= 0x030C00A7
+    if (likely(__Pyx_PyLong_IsCompact(n))) {
+        return PyLong_FromSize_t(__Pyx_PyLong_CompactValueUnsigned(n));
+    }
+#else
+    if (likely(Py_SIZE(n) == -1)) {
+        return PyLong_FromUnsignedLong(__Pyx_PyLong_Digits(n)[0]);
+    }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000
+    {
+        PyObject *copy = _PyLong_Copy((PyLongObject*)n);
+        if (likely(copy)) {
+            #if PY_VERSION_HEX >= 0x030C00A7
+            ((PyLongObject*)copy)->long_value.lv_tag = ((PyLongObject*)copy)->long_value.lv_tag & ~_PyLong_SIGN_MASK;
+            #else
+            __Pyx_SET_SIZE(copy, -Py_SIZE(copy));
+            #endif
+        }
+        return copy;
+    }
+#else
+    return PyNumber_Negative(n);
+#endif
+}
+#endif
+
+/* UnpackUnboundCMethod */
+static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) {
+    PyObject *result;
+    PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args));
+    if (unlikely(!selfless_args)) return NULL;
+    result = PyObject_Call(method, selfless_args, kwargs);
+    Py_DECREF(selfless_args);
+    return result;
+}
+static PyMethodDef __Pyx_UnboundCMethod_Def = {
+     "CythonUnboundCMethod",
+     __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall),
+     METH_VARARGS | METH_KEYWORDS,
+     NULL
+};
+static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
+    PyObject *method;
+    method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
+    if (unlikely(!method))
+        return -1;
+    target->method = method;
+#if CYTHON_COMPILING_IN_CPYTHON
+    #if PY_MAJOR_VERSION >= 3
+    if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type)))
+    #else
+    if (likely(!__Pyx_CyOrPyCFunction_Check(method)))
+    #endif
+    {
+        PyMethodDescrObject *descr = (PyMethodDescrObject*) method;
+        target->func = descr->d_method->ml_meth;
+        target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
+    } else
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+#else
+    if (PyCFunction_Check(method))
+#endif
+    {
+        PyObject *self;
+        int self_found;
+#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
+        self = PyObject_GetAttrString(method, "__self__");
+        if (!self) {
+            PyErr_Clear();
+        }
+#else
+        self = PyCFunction_GET_SELF(method);
+#endif
+        self_found = (self && self != Py_None);
+#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY
+        Py_XDECREF(self);
+#endif
+        if (self_found) {
+            PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method);
+            if (unlikely(!unbound_method)) return -1;
+            Py_DECREF(method);
+            target->method = unbound_method;
+        }
+    }
+    return 0;
+}
+
+/* CallUnboundCMethod1 */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) {
+    if (likely(cfunc->func)) {
+        int flag = cfunc->flag;
+        if (flag == METH_O) {
+            return (*(cfunc->func))(self, arg);
+        } else if ((PY_VERSION_HEX >= 0x030600B1) && flag == METH_FASTCALL) {
+            #if PY_VERSION_HEX >= 0x030700A0
+                return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, &arg, 1);
+            #else
+                return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL);
+            #endif
+        } else if ((PY_VERSION_HEX >= 0x030700A0) && flag == (METH_FASTCALL | METH_KEYWORDS)) {
+            return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL);
+        }
+    }
+    return __Pyx__CallUnboundCMethod1(cfunc, self, arg);
+}
+#endif
+static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){
+    PyObject *args, *result = NULL;
+    if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (cfunc->func && (cfunc->flag & METH_VARARGS)) {
+        args = PyTuple_New(1);
+        if (unlikely(!args)) goto bad;
+        Py_INCREF(arg);
+        PyTuple_SET_ITEM(args, 0, arg);
+        if (cfunc->flag & METH_KEYWORDS)
+            result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL);
+        else
+            result = (*cfunc->func)(self, args);
+    } else {
+        args = PyTuple_New(2);
+        if (unlikely(!args)) goto bad;
+        Py_INCREF(self);
+        PyTuple_SET_ITEM(args, 0, self);
+        Py_INCREF(arg);
+        PyTuple_SET_ITEM(args, 1, arg);
+        result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+    }
+#else
+    args = PyTuple_Pack(2, self, arg);
+    if (unlikely(!args)) goto bad;
+    result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+#endif
+bad:
+    Py_XDECREF(args);
+    return result;
+}
+
+/* CallUnboundCMethod2 */
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1
+static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) {
+    if (likely(cfunc->func)) {
+        PyObject *args[2] = {arg1, arg2};
+        if (cfunc->flag == METH_FASTCALL) {
+            #if PY_VERSION_HEX >= 0x030700A0
+            return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, args, 2);
+            #else
+            return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL);
+            #endif
+        }
+        #if PY_VERSION_HEX >= 0x030700A0
+        if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS))
+            return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL);
+        #endif
+    }
+    return __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2);
+}
+#endif
+static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){
+    PyObject *args, *result = NULL;
+    if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
+#if CYTHON_COMPILING_IN_CPYTHON
+    if (cfunc->func && (cfunc->flag & METH_VARARGS)) {
+        args = PyTuple_New(2);
+        if (unlikely(!args)) goto bad;
+        Py_INCREF(arg1);
+        PyTuple_SET_ITEM(args, 0, arg1);
+        Py_INCREF(arg2);
+        PyTuple_SET_ITEM(args, 1, arg2);
+        if (cfunc->flag & METH_KEYWORDS)
+            result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL);
+        else
+            result = (*cfunc->func)(self, args);
+    } else {
+        args = PyTuple_New(3);
+        if (unlikely(!args)) goto bad;
+        Py_INCREF(self);
+        PyTuple_SET_ITEM(args, 0, self);
+        Py_INCREF(arg1);
+        PyTuple_SET_ITEM(args, 1, arg1);
+        Py_INCREF(arg2);
+        PyTuple_SET_ITEM(args, 2, arg2);
+        result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+    }
+#else
+    args = PyTuple_Pack(3, self, arg1, arg2);
+    if (unlikely(!args)) goto bad;
+    result = __Pyx_PyObject_Call(cfunc->method, args, NULL);
+#endif
+bad:
+    Py_XDECREF(args);
+    return result;
+}
+
+/* dict_getitem_default */
+static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) {
+    PyObject* value;
+#if PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (unlikely(PyErr_Occurred()))
+            return NULL;
+        value = default_value;
+    }
+    Py_INCREF(value);
+    if ((1));
+#else
+    if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) {
+        value = PyDict_GetItem(d, key);
+        if (unlikely(!value)) {
+            value = default_value;
+        }
+        Py_INCREF(value);
+    }
+#endif
+    else {
+        if (default_value == Py_None)
+            value = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyDict_Type_get, d, key);
+        else
+            value = __Pyx_CallUnboundCMethod2(&__pyx_umethod_PyDict_Type_get, d, key, default_value);
+    }
+    return value;
+}
+
+/* KeywordStringCheck */
+static int __Pyx_CheckKeywordStrings(
+    PyObject *kw,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) {
+        Py_ssize_t kwsize;
+#if CYTHON_ASSUME_SAFE_MACROS
+        kwsize = PyTuple_GET_SIZE(kw);
+#else
+        kwsize = PyTuple_Size(kw);
+        if (kwsize < 0) return 0;
+#endif
+        if (unlikely(kwsize == 0))
+            return 1;
+        if (!kw_allowed) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, 0);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            goto invalid_keyword;
+        }
+#if PY_VERSION_HEX < 0x03090000
+        for (pos = 0; pos < kwsize; pos++) {
+#if CYTHON_ASSUME_SAFE_MACROS
+            key = PyTuple_GET_ITEM(kw, pos);
+#else
+            key = PyTuple_GetItem(kw, pos);
+            if (!key) return 0;
+#endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+        }
+#endif
+        return 1;
+    }
+    while (PyDict_Next(kw, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if (!kw_allowed && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
+#endif
+invalid_keyword:
+    #if PY_MAJOR_VERSION < 3
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+    PyErr_Format(PyExc_TypeError,
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
+
+/* PyFloatBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static int __Pyx_PyFloat_BoolNeObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) {
+    const double b = floatval;
+    double a;
+    CYTHON_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    if (op1 == op2) {
+        return 0;
+    }
+    if (likely(PyFloat_CheckExact(op1))) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        a = __pyx_PyFloat_AsDouble(op1);
+#else
+        a = PyFloat_AS_DOUBLE(op1);
+#endif
+        
+    } else
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        a = (double) PyInt_AS_LONG(op1);
+        
+    } else
+    #endif
+    if (likely(PyLong_CheckExact(op1))) {
+        #if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsZero(op1)) {
+            a = 0.0;
+            
+        } else if (__Pyx_PyLong_IsCompact(op1)) {
+            a = (double) __Pyx_PyLong_CompactValue(op1);
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(op1);
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
+            switch (size) {
+                case -2:
+                case 2:
+                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -2)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                case 3:
+                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -3)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                case 4:
+                    if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -4)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                default:
+        #endif
+                    return __Pyx_PyObject_IsTrueAndDecref(
+                        PyFloat_Type.tp_richcompare(op2, op1, Py_NE));
+        #if CYTHON_USE_PYLONG_INTERNALS
+            }
+        }
+        #endif
+    } else {
+        return __Pyx_PyObject_IsTrueAndDecref(
+            PyObject_RichCompare(op1, op2, Py_NE));
+    }
+        if (a != b) {
+            return 1;
+        } else {
+            return 0;
+        }
+}
+#endif
+
+/* GetAttr3 */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static PyObject *__Pyx_GetAttr3Default(PyObject *d) {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError)))
+        return NULL;
+    __Pyx_PyErr_Clear();
+    Py_INCREF(d);
+    return d;
+}
+#endif
+static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
+    PyObject *r;
+#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1
+    int res = PyObject_GetOptionalAttr(o, n, &r);
+    return (res != 0) ? r : __Pyx_NewRef(d);
+#else
+  #if CYTHON_USE_TYPE_SLOTS
+    if (likely(PyString_Check(n))) {
+        r = __Pyx_PyObject_GetAttrStrNoError(o, n);
+        if (unlikely(!r) && likely(!PyErr_Occurred())) {
+            r = __Pyx_NewRef(d);
+        }
+        return r;
+    }
+  #endif
+    r = PyObject_GetAttr(o, n);
+    return (likely(r)) ? r : __Pyx_GetAttr3Default(d);
+#endif
+}
+
+/* RaiseUnexpectedTypeError */
+static int
+__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj)
+{
+    __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME,
+                 expected, obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
+}
+
+/* PyFloatBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static int __Pyx_PyFloat_BoolEqObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) {
+    const double b = floatval;
+    double a;
+    CYTHON_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    if (op1 == op2) {
+        return 1;
+    }
+    if (likely(PyFloat_CheckExact(op1))) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        a = __pyx_PyFloat_AsDouble(op1);
+#else
+        a = PyFloat_AS_DOUBLE(op1);
+#endif
+        
+    } else
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        a = (double) PyInt_AS_LONG(op1);
+        
+    } else
+    #endif
+    if (likely(PyLong_CheckExact(op1))) {
+        #if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsZero(op1)) {
+            a = 0.0;
+            
+        } else if (__Pyx_PyLong_IsCompact(op1)) {
+            a = (double) __Pyx_PyLong_CompactValue(op1);
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(op1);
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
+            switch (size) {
+                case -2:
+                case 2:
+                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -2)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                case 3:
+                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -3)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                case 4:
+                    if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -4)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                default:
+        #endif
+                    return __Pyx_PyObject_IsTrueAndDecref(
+                        PyFloat_Type.tp_richcompare(op2, op1, Py_EQ));
+        #if CYTHON_USE_PYLONG_INTERNALS
+            }
+        }
+        #endif
+    } else {
+        return __Pyx_PyObject_IsTrueAndDecref(
+            PyObject_RichCompare(op1, op2, Py_EQ));
+    }
+        if (a == b) {
+            return 1;
+        } else {
+            return 0;
+        }
+}
+#endif
+
+/* PyObjectFormatAndDecref */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) {
+    if (unlikely(!s)) return NULL;
+    if (likely(PyUnicode_CheckExact(s))) return s;
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyString_CheckExact(s))) {
+        PyObject *result = PyUnicode_FromEncodedObject(s, NULL, "strict");
+        Py_DECREF(s);
+        return result;
+    }
+    #endif
+    return __Pyx_PyObject_FormatAndDecref(s, f);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) {
+    PyObject *result;
+    if (unlikely(!s)) return NULL;
+    result = PyObject_Format(s, f);
+    Py_DECREF(s);
+    return result;
+}
+
+/* JoinPyUnicode */
+static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength,
+                                      Py_UCS4 max_char) {
+#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    PyObject *result_uval;
+    int result_ukind, kind_shift;
+    Py_ssize_t i, char_pos;
+    void *result_udata;
+    CYTHON_MAYBE_UNUSED_VAR(max_char);
+#if CYTHON_PEP393_ENABLED
+    result_uval = PyUnicode_New(result_ulength, max_char);
+    if (unlikely(!result_uval)) return NULL;
+    result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND;
+    kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1;
+    result_udata = PyUnicode_DATA(result_uval);
+#else
+    result_uval = PyUnicode_FromUnicode(NULL, result_ulength);
+    if (unlikely(!result_uval)) return NULL;
+    result_ukind = sizeof(Py_UNICODE);
+    kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1;
+    result_udata = PyUnicode_AS_UNICODE(result_uval);
+#endif
+    assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0);
+    char_pos = 0;
+    for (i=0; i < value_count; i++) {
+        int ukind;
+        Py_ssize_t ulength;
+        void *udata;
+        PyObject *uval = PyTuple_GET_ITEM(value_tuple, i);
+        if (unlikely(__Pyx_PyUnicode_READY(uval)))
+            goto bad;
+        ulength = __Pyx_PyUnicode_GET_LENGTH(uval);
+        if (unlikely(!ulength))
+            continue;
+        if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos))
+            goto overflow;
+        ukind = __Pyx_PyUnicode_KIND(uval);
+        udata = __Pyx_PyUnicode_DATA(uval);
+        if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) {
+            memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift));
+        } else {
+            #if PY_VERSION_HEX >= 0x030d0000
+            if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad;
+            #elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters)
+            _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength);
+            #else
+            Py_ssize_t j;
+            for (j=0; j < ulength; j++) {
+                Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j);
+                __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar);
+            }
+            #endif
+        }
+        char_pos += ulength;
+    }
+    return result_uval;
+overflow:
+    PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string");
+bad:
+    Py_DECREF(result_uval);
+    return NULL;
+#else
+    CYTHON_UNUSED_VAR(max_char);
+    CYTHON_UNUSED_VAR(result_ulength);
+    CYTHON_UNUSED_VAR(value_count);
+    return PyUnicode_Join(__pyx_empty_unicode, value_tuple);
+#endif
+}
+
+/* PyObjectCall2Args */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) {
+    PyObject *args[3] = {NULL, arg1, arg2};
+    return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+}
+
+/* PyObjectCallMethod1 */
+#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2)
+static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) {
+    PyObject *result = __Pyx_PyObject_CallOneArg(method, arg);
+    Py_DECREF(method);
+    return result;
+}
+#endif
+static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
+#if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2
+    PyObject *args[2] = {obj, arg};
+    (void) __Pyx_PyObject_GetMethod;
+    (void) __Pyx_PyObject_CallOneArg;
+    (void) __Pyx_PyObject_Call2Args;
+    return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
+#else
+    PyObject *method = NULL, *result;
+    int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method);
+    if (likely(is_method)) {
+        result = __Pyx_PyObject_Call2Args(method, obj, arg);
+        Py_DECREF(method);
+        return result;
+    }
+    if (unlikely(!method)) return NULL;
+    return __Pyx__PyObject_CallMethod1(method, arg);
+#endif
+}
+
+/* append */
+static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
+    if (likely(PyList_CheckExact(L))) {
+        if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1;
+    } else {
+        PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x);
+        if (unlikely(!retval))
+            return -1;
+        Py_DECREF(retval);
+    }
+    return 0;
+}
+
+/* WriteUnraisableException */
+static void __Pyx_WriteUnraisable(const char *name, int clineno,
+                                  int lineno, const char *filename,
+                                  int full_traceback, int nogil) {
+    PyObject *old_exc, *old_val, *old_tb;
+    PyObject *ctx;
+    __Pyx_PyThreadState_declare
+#ifdef WITH_THREAD
+    PyGILState_STATE state;
+    if (nogil)
+        state = PyGILState_Ensure();
+    else state = (PyGILState_STATE)0;
+#endif
+    CYTHON_UNUSED_VAR(clineno);
+    CYTHON_UNUSED_VAR(lineno);
+    CYTHON_UNUSED_VAR(filename);
+    CYTHON_MAYBE_UNUSED_VAR(nogil);
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
+    if (full_traceback) {
+        Py_XINCREF(old_exc);
+        Py_XINCREF(old_val);
+        Py_XINCREF(old_tb);
+        __Pyx_ErrRestore(old_exc, old_val, old_tb);
+        PyErr_PrintEx(1);
+    }
+    #if PY_MAJOR_VERSION < 3
+    ctx = PyString_FromString(name);
+    #else
+    ctx = PyUnicode_FromString(name);
+    #endif
+    __Pyx_ErrRestore(old_exc, old_val, old_tb);
+    if (!ctx) {
+        PyErr_WriteUnraisable(Py_None);
+    } else {
+        PyErr_WriteUnraisable(ctx);
+        Py_DECREF(ctx);
+    }
+#ifdef WITH_THREAD
+    if (nogil)
+        PyGILState_Release(state);
+#endif
+}
+
+/* PyIntBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_MAYBE_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long x;
+        long a = PyInt_AS_LONG(op1);
+        
+            x = (long)((unsigned long)a + (unsigned long)b);
+            if (likely((x^a) >= 0 || (x^b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_add(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        if (unlikely(__Pyx_PyLong_IsZero(op1))) {
+            return __Pyx_NewRef(op2);
+        }
+        if (likely(__Pyx_PyLong_IsCompact(op1))) {
+            a = __Pyx_PyLong_CompactValue(op1);
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(op1);
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
+            }
+        }
+                x = a + b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla + llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        double a = __pyx_PyFloat_AsDouble(op1);
+#else
+        double a = PyFloat_AS_DOUBLE(op1);
+#endif
+            double result;
+            
+            PyFPE_START_PROTECT("add", return NULL)
+            result = ((double)a) + (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+}
+#endif
+
+/* PyIntBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_MAYBE_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long x;
+        long a = PyInt_AS_LONG(op1);
+        
+            x = (long)((unsigned long)a - (unsigned long)b);
+            if (likely((x^a) >= 0 || (x^~b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_subtract(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        if (unlikely(__Pyx_PyLong_IsZero(op1))) {
+            return PyLong_FromLong(-intval);
+        }
+        if (likely(__Pyx_PyLong_IsCompact(op1))) {
+            a = __Pyx_PyLong_CompactValue(op1);
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(op1);
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+                    #endif
+                    }
+                    CYTHON_FALLTHROUGH;
+                default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2);
+            }
+        }
+                x = a - b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla - llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        double a = __pyx_PyFloat_AsDouble(op1);
+#else
+        double a = PyFloat_AS_DOUBLE(op1);
+#endif
+            double result;
+            
+            PyFPE_START_PROTECT("subtract", return NULL)
+            result = ((double)a) - (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2);
+}
+#endif
+
+/* ExtTypeTest */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    __Pyx_TypeName obj_type_name;
+    __Pyx_TypeName type_name;
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (likely(__Pyx_TypeCheck(obj, type)))
+        return 1;
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    type_name = __Pyx_PyType_GetName(type);
+    PyErr_Format(PyExc_TypeError,
+                 "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME,
+                 obj_type_name, type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    return 0;
+}
+
+/* DictGetItem */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            if (unlikely(PyTuple_Check(key))) {
+                PyObject* args = PyTuple_Pack(1, key);
+                if (likely(args)) {
+                    PyErr_SetObject(PyExc_KeyError, args);
+                    Py_DECREF(args);
+                }
+            } else {
+                PyErr_SetObject(PyExc_KeyError, key);
+            }
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#endif
+
+/* decode_c_string */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
+         const char* cstring, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    Py_ssize_t length;
+    if (unlikely((start < 0) | (stop < 0))) {
+        size_t slen = strlen(cstring);
+        if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) {
+            PyErr_SetString(PyExc_OverflowError,
+                            "c-string too long to convert to Python");
+            return NULL;
+        }
+        length = (Py_ssize_t) slen;
+        if (start < 0) {
+            start += length;
+            if (start < 0)
+                start = 0;
+        }
+        if (stop < 0)
+            stop += length;
+    }
+    if (unlikely(stop <= start))
+        return __Pyx_NewRef(__pyx_empty_unicode);
+    length = stop - start;
+    cstring += start;
+    if (decode_func) {
+        return decode_func(cstring, length, errors);
+    } else {
+        return PyUnicode_Decode(cstring, length, encoding, errors);
+    }
+}
+
+/* GetAttr */
+static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
+#if CYTHON_USE_TYPE_SLOTS
+#if PY_MAJOR_VERSION >= 3
+    if (likely(PyUnicode_Check(n)))
+#else
+    if (likely(PyString_Check(n)))
+#endif
+        return __Pyx_PyObject_GetAttrStr(o, n);
+#endif
+    return PyObject_GetAttr(o, n);
+}
+
+/* decode_c_bytes */
+static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
+         const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
+         const char* encoding, const char* errors,
+         PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
+    if (unlikely((start < 0) | (stop < 0))) {
+        if (start < 0) {
+            start += length;
+            if (start < 0)
+                start = 0;
+        }
+        if (stop < 0)
+            stop += length;
+    }
+    if (stop > length)
+        stop = length;
+    if (unlikely(stop <= start))
+        return __Pyx_NewRef(__pyx_empty_unicode);
+    length = stop - start;
+    cstring += start;
+    if (decode_func) {
+        return decode_func(cstring, length, errors);
+    } else {
+        return PyUnicode_Decode(cstring, length, encoding, errors);
+    }
+}
+
+/* ArgTypeTest */
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact)
+{
+    __Pyx_TypeName type_name;
+    __Pyx_TypeName obj_type_name;
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    else if (exact) {
+        #if PY_MAJOR_VERSION == 2
+        if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(__Pyx_TypeCheck(obj, type))) return 1;
+    }
+    type_name = __Pyx_PyType_GetName(type);
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME
+        ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name);
+    __Pyx_DECREF_TypeName(type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return 0;
+}
+
+/* PyIntCompare */
+static CYTHON_INLINE int __Pyx_PyInt_BoolNeObjC(PyObject *op1, PyObject *op2, long intval, long inplace) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_UNUSED_VAR(inplace);
+    if (op1 == op2) {
+        return 0;
+    }
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long a = PyInt_AS_LONG(op1);
+        return (a != b);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        int unequal;
+        unsigned long uintval;
+        Py_ssize_t size = __Pyx_PyLong_DigitCount(op1);
+        const digit* digits = __Pyx_PyLong_Digits(op1);
+        if (intval == 0) {
+            return (__Pyx_PyLong_IsZero(op1) != 1);
+        } else if (intval < 0) {
+            if (__Pyx_PyLong_IsNonNeg(op1))
+                return 1;
+            intval = -intval;
+        } else {
+            if (__Pyx_PyLong_IsNeg(op1))
+                return 1;
+        }
+        uintval = (unsigned long) intval;
+#if PyLong_SHIFT * 4 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 4)) {
+            unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 3 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 3)) {
+            unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 2 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 2)) {
+            unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+#if PyLong_SHIFT * 1 < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * 1)) {
+            unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                 | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK));
+        } else
+#endif
+            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
+        return (unequal != 0);
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        double a = __pyx_PyFloat_AsDouble(op1);
+#else
+        double a = PyFloat_AS_DOUBLE(op1);
+#endif
+        return ((double)a != (double)b);
+    }
+    return __Pyx_PyObject_IsTrueAndDecref(
+        PyObject_RichCompare(op1, op2, Py_NE));
+}
+
+/* RaiseClosureNameError */
+static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) {
+    PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname);
+}
+
+/* PyFloatBinop */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyFloat_TrueDivideObjC(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) {
+    const double b = floatval;
+    double a, result;
+    CYTHON_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+    if (likely(PyFloat_CheckExact(op1))) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        a = __pyx_PyFloat_AsDouble(op1);
+#else
+        a = PyFloat_AS_DOUBLE(op1);
+#endif
+        
+    } else
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        a = (double) PyInt_AS_LONG(op1);
+        
+    } else
+    #endif
+    if (likely(PyLong_CheckExact(op1))) {
+        #if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsZero(op1)) {
+            a = 0.0;
+            
+        } else if (__Pyx_PyLong_IsCompact(op1)) {
+            a = (double) __Pyx_PyLong_CompactValue(op1);
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(op1);
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(op1);
+            switch (size) {
+                case -2:
+                case 2:
+                    if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (1 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -2)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -3:
+                case 3:
+                    if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (2 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -3)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                case -4:
+                case 4:
+                    if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || (3 * PyLong_SHIFT < 53))) {
+                        a = (double) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        if ((8 * sizeof(unsigned long) < 53) || (4 * PyLong_SHIFT < 53) || (a < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == -4)
+                                a = -a;
+                            break;
+                        }
+                    }
+                    CYTHON_FALLTHROUGH;
+                default:
+        #endif
+                    a = PyLong_AsDouble(op1);
+                    if (unlikely(a == -1.0 && PyErr_Occurred())) return NULL;
+        #if CYTHON_USE_PYLONG_INTERNALS
+            }
+        }
+        #endif
+    } else {
+        return (inplace ? PyNumber_InPlaceTrueDivide : PyNumber_TrueDivide)(op1, op2);
+    }
+        PyFPE_START_PROTECT("divide", return NULL)
+        result = a / b;
+        PyFPE_END_PROTECT(result)
+        return PyFloat_FromDouble(result);
+}
+#endif
+
+/* SliceObject */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
+        Py_ssize_t cstart, Py_ssize_t cstop,
+        PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
+        int has_cstart, int has_cstop, int wraparound) {
+    __Pyx_TypeName obj_type_name;
+#if CYTHON_USE_TYPE_SLOTS
+    PyMappingMethods* mp;
+#if PY_MAJOR_VERSION < 3
+    PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;
+    if (likely(ms && ms->sq_slice)) {
+        if (!has_cstart) {
+            if (_py_start && (*_py_start != Py_None)) {
+                cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);
+                if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+            } else
+                cstart = 0;
+        }
+        if (!has_cstop) {
+            if (_py_stop && (*_py_stop != Py_None)) {
+                cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);
+                if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
+            } else
+                cstop = PY_SSIZE_T_MAX;
+        }
+        if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {
+            Py_ssize_t l = ms->sq_length(obj);
+            if (likely(l >= 0)) {
+                if (cstop < 0) {
+                    cstop += l;
+                    if (cstop < 0) cstop = 0;
+                }
+                if (cstart < 0) {
+                    cstart += l;
+                    if (cstart < 0) cstart = 0;
+                }
+            } else {
+                if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                    goto bad;
+                PyErr_Clear();
+            }
+        }
+        return ms->sq_slice(obj, cstart, cstop);
+    }
+#else
+    CYTHON_UNUSED_VAR(wraparound);
+#endif
+    mp = Py_TYPE(obj)->tp_as_mapping;
+    if (likely(mp && mp->mp_subscript))
+#else
+    CYTHON_UNUSED_VAR(wraparound);
+#endif
+    {
+        PyObject* result;
+        PyObject *py_slice, *py_start, *py_stop;
+        if (_py_slice) {
+            py_slice = *_py_slice;
+        } else {
+            PyObject* owned_start = NULL;
+            PyObject* owned_stop = NULL;
+            if (_py_start) {
+                py_start = *_py_start;
+            } else {
+                if (has_cstart) {
+                    owned_start = py_start = PyInt_FromSsize_t(cstart);
+                    if (unlikely(!py_start)) goto bad;
+                } else
+                    py_start = Py_None;
+            }
+            if (_py_stop) {
+                py_stop = *_py_stop;
+            } else {
+                if (has_cstop) {
+                    owned_stop = py_stop = PyInt_FromSsize_t(cstop);
+                    if (unlikely(!py_stop)) {
+                        Py_XDECREF(owned_start);
+                        goto bad;
+                    }
+                } else
+                    py_stop = Py_None;
+            }
+            py_slice = PySlice_New(py_start, py_stop, Py_None);
+            Py_XDECREF(owned_start);
+            Py_XDECREF(owned_stop);
+            if (unlikely(!py_slice)) goto bad;
+        }
+#if CYTHON_USE_TYPE_SLOTS
+        result = mp->mp_subscript(obj, py_slice);
+#else
+        result = PyObject_GetItem(obj, py_slice);
+#endif
+        if (!_py_slice) {
+            Py_DECREF(py_slice);
+        }
+        return result;
+    }
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+        "'" __Pyx_FMT_TYPENAME "' object is unsliceable", obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+bad:
+    return NULL;
+}
+
+/* SetItemInt */
+static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
+    int r;
+    if (unlikely(!j)) return -1;
+    r = PyObject_SetItem(o, j, v);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list,
+                                               CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
+        if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) {
+            PyObject* old = PyList_GET_ITEM(o, n);
+            Py_INCREF(v);
+            PyList_SET_ITEM(o, n, v);
+            Py_DECREF(old);
+            return 1;
+        }
+    } else {
+        PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping;
+        PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence;
+        if (mm && mm->mp_ass_subscript) {
+            int r;
+            PyObject *key = PyInt_FromSsize_t(i);
+            if (unlikely(!key)) return -1;
+            r = mm->mp_ass_subscript(o, key, v);
+            Py_DECREF(key);
+            return r;
+        }
+        if (likely(sm && sm->sq_ass_item)) {
+            if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) {
+                Py_ssize_t l = sm->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return -1;
+                    PyErr_Clear();
+                }
+            }
+            return sm->sq_ass_item(o, i, v);
+        }
+    }
+#else
+    if (is_list || !PyMapping_Check(o))
+    {
+        return PySequence_SetItem(o, i, v);
+    }
+#endif
+    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
+}
+
+/* CIntToDigits */
+static const char DIGIT_PAIRS_10[2*10*10+1] = {
+    "00010203040506070809"
+    "10111213141516171819"
+    "20212223242526272829"
+    "30313233343536373839"
+    "40414243444546474849"
+    "50515253545556575859"
+    "60616263646566676869"
+    "70717273747576777879"
+    "80818283848586878889"
+    "90919293949596979899"
+};
+static const char DIGIT_PAIRS_8[2*8*8+1] = {
+    "0001020304050607"
+    "1011121314151617"
+    "2021222324252627"
+    "3031323334353637"
+    "4041424344454647"
+    "5051525354555657"
+    "6061626364656667"
+    "7071727374757677"
+};
+static const char DIGITS_HEX[2*16+1] = {
+    "0123456789abcdef"
+    "0123456789ABCDEF"
+};
+
+/* BuildPyUnicode */
+static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength,
+                                                int prepend_sign, char padding_char) {
+    PyObject *uval;
+    Py_ssize_t uoffset = ulength - clength;
+#if CYTHON_USE_UNICODE_INTERNALS
+    Py_ssize_t i;
+#if CYTHON_PEP393_ENABLED
+    void *udata;
+    uval = PyUnicode_New(ulength, 127);
+    if (unlikely(!uval)) return NULL;
+    udata = PyUnicode_DATA(uval);
+#else
+    Py_UNICODE *udata;
+    uval = PyUnicode_FromUnicode(NULL, ulength);
+    if (unlikely(!uval)) return NULL;
+    udata = PyUnicode_AS_UNICODE(uval);
+#endif
+    if (uoffset > 0) {
+        i = 0;
+        if (prepend_sign) {
+            __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-');
+            i++;
+        }
+        for (; i < uoffset; i++) {
+            __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char);
+        }
+    }
+    for (i=0; i < clength; i++) {
+        __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]);
+    }
+#else
+    {
+        PyObject *sign = NULL, *padding = NULL;
+        uval = NULL;
+        if (uoffset > 0) {
+            prepend_sign = !!prepend_sign;
+            if (uoffset > prepend_sign) {
+                padding = PyUnicode_FromOrdinal(padding_char);
+                if (likely(padding) && uoffset > prepend_sign + 1) {
+                    PyObject *tmp;
+                    PyObject *repeat = PyInt_FromSsize_t(uoffset - prepend_sign);
+                    if (unlikely(!repeat)) goto done_or_error;
+                    tmp = PyNumber_Multiply(padding, repeat);
+                    Py_DECREF(repeat);
+                    Py_DECREF(padding);
+                    padding = tmp;
+                }
+                if (unlikely(!padding)) goto done_or_error;
+            }
+            if (prepend_sign) {
+                sign = PyUnicode_FromOrdinal('-');
+                if (unlikely(!sign)) goto done_or_error;
+            }
+        }
+        uval = PyUnicode_DecodeASCII(chars, clength, NULL);
+        if (likely(uval) && padding) {
+            PyObject *tmp = PyNumber_Add(padding, uval);
+            Py_DECREF(uval);
+            uval = tmp;
+        }
+        if (likely(uval) && sign) {
+            PyObject *tmp = PyNumber_Add(sign, uval);
+            Py_DECREF(uval);
+            uval = tmp;
+        }
+done_or_error:
+        Py_XDECREF(padding);
+        Py_XDECREF(sign);
+    }
+#endif
+    return uval;
+}
+
+/* CIntToPyUnicode */
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) {
+    char digits[sizeof(Py_ssize_t)*3+2];
+    char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2;
+    const char *hex_digits = DIGITS_HEX;
+    Py_ssize_t length, ulength;
+    int prepend_sign, last_one_off;
+    Py_ssize_t remaining;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (format_char == 'X') {
+        hex_digits += 16;
+        format_char = 'x';
+    }
+    remaining = value;
+    last_one_off = 0;
+    dpos = end;
+    do {
+        int digit_pos;
+        switch (format_char) {
+        case 'o':
+            digit_pos = abs((int)(remaining % (8*8)));
+            remaining = (Py_ssize_t) (remaining / (8*8));
+            dpos -= 2;
+            memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2);
+            last_one_off = (digit_pos < 8);
+            break;
+        case 'd':
+            digit_pos = abs((int)(remaining % (10*10)));
+            remaining = (Py_ssize_t) (remaining / (10*10));
+            dpos -= 2;
+            memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2);
+            last_one_off = (digit_pos < 10);
+            break;
+        case 'x':
+            *(--dpos) = hex_digits[abs((int)(remaining % 16))];
+            remaining = (Py_ssize_t) (remaining / 16);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+    } while (unlikely(remaining != 0));
+    assert(!last_one_off || *dpos == '0');
+    dpos += last_one_off;
+    length = end - dpos;
+    ulength = length;
+    prepend_sign = 0;
+    if (!is_unsigned && value <= neg_one) {
+        if (padding_char == ' ' || width <= length + 1) {
+            *(--dpos) = '-';
+            ++length;
+        } else {
+            prepend_sign = 1;
+        }
+        ++ulength;
+    }
+    if (width > ulength) {
+        ulength = width;
+    }
+    if (ulength == 1) {
+        return PyUnicode_FromOrdinal(*dpos);
+    }
+    return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char);
+}
+
+/* UnicodeAsUCS4 */
+static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject* x) {
+   Py_ssize_t length;
+   #if CYTHON_PEP393_ENABLED
+   length = PyUnicode_GET_LENGTH(x);
+   if (likely(length == 1)) {
+       return PyUnicode_READ_CHAR(x, 0);
+   }
+   #else
+   length = PyUnicode_GET_SIZE(x);
+   if (likely(length == 1)) {
+       return PyUnicode_AS_UNICODE(x)[0];
+   }
+   #if Py_UNICODE_SIZE == 2
+   else if (PyUnicode_GET_SIZE(x) == 2) {
+       Py_UCS4 high_val = PyUnicode_AS_UNICODE(x)[0];
+       if (high_val >= 0xD800 && high_val <= 0xDBFF) {
+           Py_UCS4 low_val = PyUnicode_AS_UNICODE(x)[1];
+           if (low_val >= 0xDC00 && low_val <= 0xDFFF) {
+               return 0x10000 + (((high_val & ((1<<10)-1)) << 10) | (low_val & ((1<<10)-1)));
+           }
+       }
+   }
+   #endif
+   #endif
+   PyErr_Format(PyExc_ValueError,
+                "only single character unicode strings can be converted to Py_UCS4, "
+                "got length %" CYTHON_FORMAT_SSIZE_T "d", length);
+   return (Py_UCS4)-1;
+}
+
+/* object_ord */
+static long __Pyx__PyObject_Ord(PyObject* c) {
+    Py_ssize_t size;
+    if (PyBytes_Check(c)) {
+        size = PyBytes_GET_SIZE(c);
+        if (likely(size == 1)) {
+            return (unsigned char) PyBytes_AS_STRING(c)[0];
+        }
+#if PY_MAJOR_VERSION < 3
+    } else if (PyUnicode_Check(c)) {
+        return (long)__Pyx_PyUnicode_AsPy_UCS4(c);
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    } else if (PyByteArray_Check(c)) {
+        size = PyByteArray_GET_SIZE(c);
+        if (likely(size == 1)) {
+            return (unsigned char) PyByteArray_AS_STRING(c)[0];
+        }
+#endif
+    } else {
+        __Pyx_TypeName c_type_name = __Pyx_PyType_GetName(Py_TYPE(c));
+        PyErr_Format(PyExc_TypeError,
+            "ord() expected string of length 1, but " __Pyx_FMT_TYPENAME " found",
+            c_type_name);
+        __Pyx_DECREF_TypeName(c_type_name);
+        return (long)(Py_UCS4)-1;
+    }
+    PyErr_Format(PyExc_TypeError,
+        "ord() expected a character, but string of length %zd found", size);
+    return (long)(Py_UCS4)-1;
+}
+
+/* PyObjectLookupSpecial */
+#if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx__PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name, int with_error) {
+    PyObject *res;
+    PyTypeObject *tp = Py_TYPE(obj);
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(PyInstance_Check(obj)))
+        return with_error ? __Pyx_PyObject_GetAttrStr(obj, attr_name) : __Pyx_PyObject_GetAttrStrNoError(obj, attr_name);
+#endif
+    res = _PyType_Lookup(tp, attr_name);
+    if (likely(res)) {
+        descrgetfunc f = Py_TYPE(res)->tp_descr_get;
+        if (!f) {
+            Py_INCREF(res);
+        } else {
+            res = f(res, obj, (PyObject *)tp);
+        }
+    } else if (with_error) {
+        PyErr_SetObject(PyExc_AttributeError, attr_name);
+    }
+    return res;
+}
+#endif
+
+/* Import */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *module = 0;
+    PyObject *empty_dict = 0;
+    PyObject *empty_list = 0;
+    #if PY_MAJOR_VERSION < 3
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (unlikely(!py_import))
+        goto bad;
+    if (!from_list) {
+        empty_list = PyList_New(0);
+        if (unlikely(!empty_list))
+            goto bad;
+        from_list = empty_list;
+    }
+    #endif
+    empty_dict = PyDict_New();
+    if (unlikely(!empty_dict))
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if (strchr(__Pyx_MODULE_NAME, '.') != NULL) {
+                module = PyImport_ImportModuleLevelObject(
+                    name, __pyx_d, empty_dict, from_list, 1);
+                if (unlikely(!module)) {
+                    if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError)))
+                        goto bad;
+                    PyErr_Clear();
+                }
+            }
+            level = 0;
+        }
+        #endif
+        if (!module) {
+            #if PY_MAJOR_VERSION < 3
+            PyObject *py_level = PyInt_FromLong(level);
+            if (unlikely(!py_level))
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, __pyx_d, empty_dict, from_list, level);
+            #endif
+        }
+    }
+bad:
+    Py_XDECREF(empty_dict);
+    Py_XDECREF(empty_list);
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_import);
+    #endif
+    return module;
+}
+
+/* ImportFrom */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
+    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
+    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        const char* module_name_str = 0;
+        PyObject* module_name = 0;
+        PyObject* module_dot = 0;
+        PyObject* full_name = 0;
+        PyErr_Clear();
+        module_name_str = PyModule_GetName(module);
+        if (unlikely(!module_name_str)) { goto modbad; }
+        module_name = PyUnicode_FromString(module_name_str);
+        if (unlikely(!module_name)) { goto modbad; }
+        module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__114);
+        if (unlikely(!module_dot)) { goto modbad; }
+        full_name = PyUnicode_Concat(module_dot, name);
+        if (unlikely(!full_name)) { goto modbad; }
+        #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400)
+        {
+            PyObject *modules = PyImport_GetModuleDict();
+            if (unlikely(!modules))
+                goto modbad;
+            value = PyObject_GetItem(modules, full_name);
+        }
+        #else
+        value = PyImport_GetModule(full_name);
+        #endif
+      modbad:
+        Py_XDECREF(full_name);
+        Py_XDECREF(module_dot);
+        Py_XDECREF(module_name);
+    }
+    if (unlikely(!value)) {
+        PyErr_Format(PyExc_ImportError,
+        #if PY_MAJOR_VERSION < 3
+            "cannot import name %.230s", PyString_AS_STRING(name));
+        #else
+            "cannot import name %S", name);
+        #endif
+    }
+    return value;
+}
+
+/* HasAttr */
+#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1
+static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) {
+    PyObject *r;
+    if (unlikely(!__Pyx_PyBaseString_Check(n))) {
+        PyErr_SetString(PyExc_TypeError,
+                        "hasattr(): attribute name must be string");
+        return -1;
+    }
+    r = __Pyx_GetAttr(o, n);
+    if (!r) {
+        PyErr_Clear();
+        return 0;
+    } else {
+        Py_DECREF(r);
+        return 1;
+    }
+}
+#endif
+
+/* ValidateBasesTuple */
+#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS
+static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) {
+    Py_ssize_t i, n;
+#if CYTHON_ASSUME_SAFE_MACROS
+    n = PyTuple_GET_SIZE(bases);
+#else
+    n = PyTuple_Size(bases);
+    if (n < 0) return -1;
+#endif
+    for (i = 1; i < n; i++)
+    {
+#if CYTHON_AVOID_BORROWED_REFS
+        PyObject *b0 = PySequence_GetItem(bases, i);
+        if (!b0) return -1;
+#elif CYTHON_ASSUME_SAFE_MACROS
+        PyObject *b0 = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *b0 = PyTuple_GetItem(bases, i);
+        if (!b0) return -1;
+#endif
+        PyTypeObject *b;
+#if PY_MAJOR_VERSION < 3
+        if (PyClass_Check(b0))
+        {
+            PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class",
+                         PyString_AS_STRING(((PyClassObject*)b0)->cl_name));
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+#endif
+        b = (PyTypeObject*) b0;
+        if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE))
+        {
+            __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+            PyErr_Format(PyExc_TypeError,
+                "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name);
+            __Pyx_DECREF_TypeName(b_name);
+#if CYTHON_AVOID_BORROWED_REFS
+            Py_DECREF(b0);
+#endif
+            return -1;
+        }
+        if (dictoffset == 0)
+        {
+            Py_ssize_t b_dictoffset = 0;
+#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY
+            b_dictoffset = b->tp_dictoffset;
+#else
+            PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__");
+            if (!py_b_dictoffset) goto dictoffset_return;
+            b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset);
+            Py_DECREF(py_b_dictoffset);
+            if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return;
+#endif
+            if (b_dictoffset) {
+                {
+                    __Pyx_TypeName b_name = __Pyx_PyType_GetName(b);
+                    PyErr_Format(PyExc_TypeError,
+                        "extension type '%.200s' has no __dict__ slot, "
+                        "but base type '" __Pyx_FMT_TYPENAME "' has: "
+                        "either add 'cdef dict __dict__' to the extension type "
+                        "or add '__slots__ = [...]' to the base type",
+                        type_name, b_name);
+                    __Pyx_DECREF_TypeName(b_name);
+                }
+#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY)
+              dictoffset_return:
+#endif
+#if CYTHON_AVOID_BORROWED_REFS
+                Py_DECREF(b0);
+#endif
+                return -1;
+            }
+        }
+#if CYTHON_AVOID_BORROWED_REFS
+        Py_DECREF(b0);
+#endif
+    }
+    return 0;
+}
+#endif
+
+/* PyType_Ready */
+static int __Pyx_PyType_Ready(PyTypeObject *t) {
+#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION)
+    (void)__Pyx_PyObject_CallMethod0;
+#if CYTHON_USE_TYPE_SPECS
+    (void)__Pyx_validate_bases_tuple;
+#endif
+    return PyType_Ready(t);
+#else
+    int r;
+    PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*);
+    if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1))
+        return -1;
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+    {
+        int gc_was_enabled;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        gc_was_enabled = PyGC_Disable();
+        (void)__Pyx_PyObject_CallMethod0;
+    #else
+        PyObject *ret, *py_status;
+        PyObject *gc = NULL;
+        #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400)
+        gc = PyImport_GetModule(__pyx_kp_u_gc);
+        #endif
+        if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc);
+        if (unlikely(!gc)) return -1;
+        py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled);
+        if (unlikely(!py_status)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+        gc_was_enabled = __Pyx_PyObject_IsTrue(py_status);
+        Py_DECREF(py_status);
+        if (gc_was_enabled > 0) {
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable);
+            if (unlikely(!ret)) {
+                Py_DECREF(gc);
+                return -1;
+            }
+            Py_DECREF(ret);
+        } else if (unlikely(gc_was_enabled == -1)) {
+            Py_DECREF(gc);
+            return -1;
+        }
+    #endif
+        t->tp_flags |= Py_TPFLAGS_HEAPTYPE;
+#if PY_VERSION_HEX >= 0x030A0000
+        t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
+#endif
+#else
+        (void)__Pyx_PyObject_CallMethod0;
+#endif
+    r = PyType_Ready(t);
+#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION)
+        t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE;
+    #if PY_VERSION_HEX >= 0x030A00b1
+        if (gc_was_enabled)
+            PyGC_Enable();
+    #else
+        if (gc_was_enabled) {
+            PyObject *tp, *v, *tb;
+            PyErr_Fetch(&tp, &v, &tb);
+            ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable);
+            if (likely(ret || r == -1)) {
+                Py_XDECREF(ret);
+                PyErr_Restore(tp, v, tb);
+            } else {
+                Py_XDECREF(tp);
+                Py_XDECREF(v);
+                Py_XDECREF(tb);
+                r = -1;
+            }
+        }
+        Py_DECREF(gc);
+    #endif
+    }
+#endif
+    return r;
+#endif
+}
+
+/* PyObject_GenericGetAttrNoDict */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) {
+    __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp);
+    PyErr_Format(PyExc_AttributeError,
+#if PY_MAJOR_VERSION >= 3
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'",
+                 type_name, attr_name);
+#else
+                 "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'",
+                 type_name, PyString_AS_STRING(attr_name));
+#endif
+    __Pyx_DECREF_TypeName(type_name);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) {
+    PyObject *descr;
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (unlikely(!PyString_Check(attr_name))) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    assert(!tp->tp_dictoffset);
+    descr = _PyType_Lookup(tp, attr_name);
+    if (unlikely(!descr)) {
+        return __Pyx_RaiseGenericGetAttributeError(tp, attr_name);
+    }
+    Py_INCREF(descr);
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS)))
+    #endif
+    {
+        descrgetfunc f = Py_TYPE(descr)->tp_descr_get;
+        if (unlikely(f)) {
+            PyObject *res = f(descr, obj, (PyObject *)tp);
+            Py_DECREF(descr);
+            return res;
+        }
+    }
+    return descr;
+}
+#endif
+
+/* PyObject_GenericGetAttr */
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000
+static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) {
+    if (unlikely(Py_TYPE(obj)->tp_dictoffset)) {
+        return PyObject_GenericGetAttr(obj, attr_name);
+    }
+    return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name);
+}
+#endif
+
+/* SetupReduce */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) {
+  int ret;
+  PyObject *name_attr;
+  name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name_2);
+  if (likely(name_attr)) {
+      ret = PyObject_RichCompareBool(name_attr, name, Py_EQ);
+  } else {
+      ret = -1;
+  }
+  if (unlikely(ret < 0)) {
+      PyErr_Clear();
+      ret = 0;
+  }
+  Py_XDECREF(name_attr);
+  return ret;
+}
+static int __Pyx_setup_reduce(PyObject* type_obj) {
+    int ret = 0;
+    PyObject *object_reduce = NULL;
+    PyObject *object_getstate = NULL;
+    PyObject *object_reduce_ex = NULL;
+    PyObject *reduce = NULL;
+    PyObject *reduce_ex = NULL;
+    PyObject *reduce_cython = NULL;
+    PyObject *setstate = NULL;
+    PyObject *setstate_cython = NULL;
+    PyObject *getstate = NULL;
+#if CYTHON_USE_PYTYPE_LOOKUP
+    getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate);
+#else
+    getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate);
+    if (!getstate && PyErr_Occurred()) {
+        goto __PYX_BAD;
+    }
+#endif
+    if (getstate) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate);
+#else
+        object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate);
+        if (!object_getstate && PyErr_Occurred()) {
+            goto __PYX_BAD;
+        }
+#endif
+        if (object_getstate != getstate) {
+            goto __PYX_GOOD;
+        }
+    }
+#if CYTHON_USE_PYTYPE_LOOKUP
+    object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#else
+    object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD;
+#endif
+    reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD;
+    if (reduce_ex == object_reduce_ex) {
+#if CYTHON_USE_PYTYPE_LOOKUP
+        object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#else
+        object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD;
+#endif
+        reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD;
+        if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) {
+            reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython);
+            if (likely(reduce_cython)) {
+                ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+            } else if (reduce == object_reduce || PyErr_Occurred()) {
+                goto __PYX_BAD;
+            }
+            setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate);
+            if (!setstate) PyErr_Clear();
+            if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) {
+                setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython);
+                if (likely(setstate_cython)) {
+                    ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                    ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD;
+                } else if (!setstate || PyErr_Occurred()) {
+                    goto __PYX_BAD;
+                }
+            }
+            PyType_Modified((PyTypeObject*)type_obj);
+        }
+    }
+    goto __PYX_GOOD;
+__PYX_BAD:
+    if (!PyErr_Occurred()) {
+        __Pyx_TypeName type_obj_name =
+            __Pyx_PyType_GetName((PyTypeObject*)type_obj);
+        PyErr_Format(PyExc_RuntimeError,
+            "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name);
+        __Pyx_DECREF_TypeName(type_obj_name);
+    }
+    ret = -1;
+__PYX_GOOD:
+#if !CYTHON_USE_PYTYPE_LOOKUP
+    Py_XDECREF(object_reduce);
+    Py_XDECREF(object_reduce_ex);
+    Py_XDECREF(object_getstate);
+    Py_XDECREF(getstate);
+#endif
+    Py_XDECREF(reduce);
+    Py_XDECREF(reduce_ex);
+    Py_XDECREF(reduce_cython);
+    Py_XDECREF(setstate);
+    Py_XDECREF(setstate_cython);
+    return ret;
+}
+#endif
+
+/* SetVTable */
+static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) {
+    PyObject *ob = PyCapsule_New(vtable, 0, 0);
+    if (unlikely(!ob))
+        goto bad;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0))
+#else
+    if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0))
+#endif
+        goto bad;
+    Py_DECREF(ob);
+    return 0;
+bad:
+    Py_XDECREF(ob);
+    return -1;
+}
+
+/* GetVTable */
+static void* __Pyx_GetVtable(PyTypeObject *type) {
+    void* ptr;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable);
+#else
+    PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable);
+#endif
+    if (!ob)
+        goto bad;
+    ptr = PyCapsule_GetPointer(ob, 0);
+    if (!ptr && !PyErr_Occurred())
+        PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type");
+    Py_DECREF(ob);
+    return ptr;
+bad:
+    Py_XDECREF(ob);
+    return NULL;
+}
+
+/* MergeVTables */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __Pyx_MergeVtables(PyTypeObject *type) {
+    int i;
+    void** base_vtables;
+    __Pyx_TypeName tp_base_name;
+    __Pyx_TypeName base_name;
+    void* unknown = (void*)-1;
+    PyObject* bases = type->tp_bases;
+    int base_depth = 0;
+    {
+        PyTypeObject* base = type->tp_base;
+        while (base) {
+            base_depth += 1;
+            base = base->tp_base;
+        }
+    }
+    base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1));
+    base_vtables[0] = unknown;
+    for (i = 1; i < PyTuple_GET_SIZE(bases); i++) {
+        void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i)));
+        if (base_vtable != NULL) {
+            int j;
+            PyTypeObject* base = type->tp_base;
+            for (j = 0; j < base_depth; j++) {
+                if (base_vtables[j] == unknown) {
+                    base_vtables[j] = __Pyx_GetVtable(base);
+                    base_vtables[j + 1] = unknown;
+                }
+                if (base_vtables[j] == base_vtable) {
+                    break;
+                } else if (base_vtables[j] == NULL) {
+                    goto bad;
+                }
+                base = base->tp_base;
+            }
+        }
+    }
+    PyErr_Clear();
+    free(base_vtables);
+    return 0;
+bad:
+    tp_base_name = __Pyx_PyType_GetName(type->tp_base);
+    base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i));
+    PyErr_Format(PyExc_TypeError,
+        "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name);
+    __Pyx_DECREF_TypeName(tp_base_name);
+    __Pyx_DECREF_TypeName(base_name);
+    free(base_vtables);
+    return -1;
+}
+#endif
+
+/* TypeImport */
+#ifndef __PYX_HAVE_RT_ImportType_3_0_10
+#define __PYX_HAVE_RT_ImportType_3_0_10
+static PyTypeObject *__Pyx_ImportType_3_0_10(PyObject *module, const char *module_name, const char *class_name,
+    size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_0_10 check_size)
+{
+    PyObject *result = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+    Py_ssize_t itemsize;
+#if CYTHON_COMPILING_IN_LIMITED_API
+    PyObject *py_basicsize;
+    PyObject *py_itemsize;
+#endif
+    result = PyObject_GetAttrString(module, class_name);
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#if !CYTHON_COMPILING_IN_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+    itemsize = ((PyTypeObject *)result)->tp_itemsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+    py_itemsize = PyObject_GetAttrString(result, "__itemsize__");
+    if (!py_itemsize)
+        goto bad;
+    itemsize = PyLong_AsSsize_t(py_itemsize);
+    Py_DECREF(py_itemsize);
+    py_itemsize = 0;
+    if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (itemsize) {
+        if (size % alignment) {
+            alignment = size % alignment;
+        }
+        if (itemsize < (Py_ssize_t)alignment)
+            itemsize = (Py_ssize_t)alignment;
+    }
+    if ((size_t)(basicsize + itemsize) < size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize+itemsize);
+        goto bad;
+    }
+    if (check_size == __Pyx_ImportType_CheckSize_Error_3_0_10 &&
+            ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd-%zd from PyObject",
+            module_name, class_name, size, basicsize, basicsize+itemsize);
+        goto bad;
+    }
+    else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_0_10 && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. "
+            "Expected %zd from C header, got %zd from PyObject",
+            module_name, class_name, size, basicsize);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* ImportDottedModule */
+#if PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) {
+    PyObject *partial_name = NULL, *slice = NULL, *sep = NULL;
+    if (unlikely(PyErr_Occurred())) {
+        PyErr_Clear();
+    }
+    if (likely(PyTuple_GET_SIZE(parts_tuple) == count)) {
+        partial_name = name;
+    } else {
+        slice = PySequence_GetSlice(parts_tuple, 0, count);
+        if (unlikely(!slice))
+            goto bad;
+        sep = PyUnicode_FromStringAndSize(".", 1);
+        if (unlikely(!sep))
+            goto bad;
+        partial_name = PyUnicode_Join(sep, slice);
+    }
+    PyErr_Format(
+#if PY_MAJOR_VERSION < 3
+        PyExc_ImportError,
+        "No module named '%s'", PyString_AS_STRING(partial_name));
+#else
+#if PY_VERSION_HEX >= 0x030600B1
+        PyExc_ModuleNotFoundError,
+#else
+        PyExc_ImportError,
+#endif
+        "No module named '%U'", partial_name);
+#endif
+bad:
+    Py_XDECREF(sep);
+    Py_XDECREF(slice);
+    Py_XDECREF(partial_name);
+    return NULL;
+}
+#endif
+#if PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) {
+    PyObject *imported_module;
+#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM  < 0x07030400)
+    PyObject *modules = PyImport_GetModuleDict();
+    if (unlikely(!modules))
+        return NULL;
+    imported_module = __Pyx_PyDict_GetItemStr(modules, name);
+    Py_XINCREF(imported_module);
+#else
+    imported_module = PyImport_GetModule(name);
+#endif
+    return imported_module;
+}
+#endif
+#if PY_MAJOR_VERSION >= 3
+static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) {
+    Py_ssize_t i, nparts;
+    nparts = PyTuple_GET_SIZE(parts_tuple);
+    for (i=1; i < nparts && module; i++) {
+        PyObject *part, *submodule;
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        part = PyTuple_GET_ITEM(parts_tuple, i);
+#else
+        part = PySequence_ITEM(parts_tuple, i);
+#endif
+        submodule = __Pyx_PyObject_GetAttrStrNoError(module, part);
+#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
+        Py_DECREF(part);
+#endif
+        Py_DECREF(module);
+        module = submodule;
+    }
+    if (unlikely(!module)) {
+        return __Pyx__ImportDottedModule_Error(name, parts_tuple, i);
+    }
+    return module;
+}
+#endif
+static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) {
+#if PY_MAJOR_VERSION < 3
+    PyObject *module, *from_list, *star = __pyx_n_s__126;
+    CYTHON_UNUSED_VAR(parts_tuple);
+    from_list = PyList_New(1);
+    if (unlikely(!from_list))
+        return NULL;
+    Py_INCREF(star);
+    PyList_SET_ITEM(from_list, 0, star);
+    module = __Pyx_Import(name, from_list, 0);
+    Py_DECREF(from_list);
+    return module;
+#else
+    PyObject *imported_module;
+    PyObject *module = __Pyx_Import(name, NULL, 0);
+    if (!parts_tuple || unlikely(!module))
+        return module;
+    imported_module = __Pyx__ImportDottedModule_Lookup(name);
+    if (likely(imported_module)) {
+        Py_DECREF(module);
+        return imported_module;
+    }
+    PyErr_Clear();
+    return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple);
+#endif
+}
+static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1
+    PyObject *module = __Pyx__ImportDottedModule_Lookup(name);
+    if (likely(module)) {
+        PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec);
+        if (likely(spec)) {
+            PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_initializing);
+            if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) {
+                Py_DECREF(spec);
+                spec = NULL;
+            }
+            Py_XDECREF(unsafe);
+        }
+        if (likely(!spec)) {
+            PyErr_Clear();
+            return module;
+        }
+        Py_DECREF(spec);
+        Py_DECREF(module);
+    } else if (PyErr_Occurred()) {
+        PyErr_Clear();
+    }
+#endif
+    return __Pyx__ImportDottedModule(name, parts_tuple);
+}
+
+/* CalculateMetaclass */
+static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
+    Py_ssize_t i, nbases;
+#if CYTHON_ASSUME_SAFE_MACROS
+    nbases = PyTuple_GET_SIZE(bases);
+#else
+    nbases = PyTuple_Size(bases);
+    if (nbases < 0) return NULL;
+#endif
+    for (i=0; i < nbases; i++) {
+        PyTypeObject *tmptype;
+#if CYTHON_ASSUME_SAFE_MACROS
+        PyObject *tmp = PyTuple_GET_ITEM(bases, i);
+#else
+        PyObject *tmp = PyTuple_GetItem(bases, i);
+        if (!tmp) return NULL;
+#endif
+        tmptype = Py_TYPE(tmp);
+#if PY_MAJOR_VERSION < 3
+        if (tmptype == &PyClass_Type)
+            continue;
+#endif
+        if (!metaclass) {
+            metaclass = tmptype;
+            continue;
+        }
+        if (PyType_IsSubtype(metaclass, tmptype))
+            continue;
+        if (PyType_IsSubtype(tmptype, metaclass)) {
+            metaclass = tmptype;
+            continue;
+        }
+        PyErr_SetString(PyExc_TypeError,
+                        "metaclass conflict: "
+                        "the metaclass of a derived class "
+                        "must be a (non-strict) subclass "
+                        "of the metaclasses of all its bases");
+        return NULL;
+    }
+    if (!metaclass) {
+#if PY_MAJOR_VERSION < 3
+        metaclass = &PyClass_Type;
+#else
+        metaclass = &PyType_Type;
+#endif
+    }
+    Py_INCREF((PyObject*) metaclass);
+    return (PyObject*) metaclass;
+}
+
+/* Py3ClassCreate */
+static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
+                                           PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
+    PyObject *ns;
+    if (metaclass) {
+        PyObject *prep = __Pyx_PyObject_GetAttrStrNoError(metaclass, __pyx_n_s_prepare);
+        if (prep) {
+            PyObject *pargs[3] = {NULL, name, bases};
+            ns = __Pyx_PyObject_FastCallDict(prep, pargs+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, mkw);
+            Py_DECREF(prep);
+        } else {
+            if (unlikely(PyErr_Occurred()))
+                return NULL;
+            ns = PyDict_New();
+        }
+    } else {
+        ns = PyDict_New();
+    }
+    if (unlikely(!ns))
+        return NULL;
+    if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad;
+#if PY_VERSION_HEX >= 0x03030000
+    if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad;
+#else
+    CYTHON_MAYBE_UNUSED_VAR(qualname);
+#endif
+    if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad;
+    return ns;
+bad:
+    Py_DECREF(ns);
+    return NULL;
+}
+#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS
+static int __Pyx_SetNamesPEP487(PyObject *type_obj) {
+    PyTypeObject *type = (PyTypeObject*) type_obj;
+    PyObject *names_to_set, *key, *value, *set_name, *tmp;
+    Py_ssize_t i = 0;
+#if CYTHON_USE_TYPE_SLOTS
+    names_to_set = PyDict_Copy(type->tp_dict);
+#else
+    {
+        PyObject *d = PyObject_GetAttr(type_obj, __pyx_n_s_dict);
+        names_to_set = NULL;
+        if (likely(d)) {
+            PyObject *names_to_set = PyDict_New();
+            int ret = likely(names_to_set) ? PyDict_Update(names_to_set, d) : -1;
+            Py_DECREF(d);
+            if (unlikely(ret < 0))
+                Py_CLEAR(names_to_set);
+        }
+    }
+#endif
+    if (unlikely(names_to_set == NULL))
+        goto bad;
+    while (PyDict_Next(names_to_set, &i, &key, &value)) {
+        set_name = __Pyx_PyObject_LookupSpecialNoError(value, __pyx_n_s_set_name);
+        if (unlikely(set_name != NULL)) {
+            tmp = __Pyx_PyObject_Call2Args(set_name, type_obj, key);
+            Py_DECREF(set_name);
+            if (unlikely(tmp == NULL)) {
+                __Pyx_TypeName value_type_name =
+                    __Pyx_PyType_GetName(Py_TYPE(value));
+                __Pyx_TypeName type_name = __Pyx_PyType_GetName(type);
+                PyErr_Format(PyExc_RuntimeError,
+#if PY_MAJOR_VERSION >= 3
+                    "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %R " "in '" __Pyx_FMT_TYPENAME "'",
+                    value_type_name, key, type_name);
+#else
+                    "Error calling __set_name__ on '" __Pyx_FMT_TYPENAME "' instance %.100s in '" __Pyx_FMT_TYPENAME "'",
+                    value_type_name,
+                    PyString_Check(key) ? PyString_AS_STRING(key) : "?",
+                    type_name);
+#endif
+                goto bad;
+            } else {
+                Py_DECREF(tmp);
+            }
+        }
+        else if (unlikely(PyErr_Occurred())) {
+            goto bad;
+        }
+    }
+    Py_DECREF(names_to_set);
+    return 0;
+bad:
+    Py_XDECREF(names_to_set);
+    return -1;
+}
+static PyObject *__Pyx_InitSubclassPEP487(PyObject *type_obj, PyObject *mkw) {
+#if CYTHON_USE_TYPE_SLOTS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    PyTypeObject *type = (PyTypeObject*) type_obj;
+    PyObject *mro = type->tp_mro;
+    Py_ssize_t i, nbases;
+    if (unlikely(!mro)) goto done;
+    (void) &__Pyx_GetBuiltinName;
+    Py_INCREF(mro);
+    nbases = PyTuple_GET_SIZE(mro);
+    assert(PyTuple_GET_ITEM(mro, 0) == type_obj);
+    for (i = 1; i < nbases-1; i++) {
+        PyObject *base, *dict, *meth;
+        base = PyTuple_GET_ITEM(mro, i);
+        dict = ((PyTypeObject *)base)->tp_dict;
+        meth = __Pyx_PyDict_GetItemStrWithError(dict, __pyx_n_s_init_subclass);
+        if (unlikely(meth)) {
+            descrgetfunc f = Py_TYPE(meth)->tp_descr_get;
+            PyObject *res;
+            Py_INCREF(meth);
+            if (likely(f)) {
+                res = f(meth, NULL, type_obj);
+                Py_DECREF(meth);
+                if (unlikely(!res)) goto bad;
+                meth = res;
+            }
+            res = __Pyx_PyObject_FastCallDict(meth, NULL, 0, mkw);
+            Py_DECREF(meth);
+            if (unlikely(!res)) goto bad;
+            Py_DECREF(res);
+            goto done;
+        } else if (unlikely(PyErr_Occurred())) {
+            goto bad;
+        }
+    }
+done:
+    Py_XDECREF(mro);
+    return type_obj;
+bad:
+    Py_XDECREF(mro);
+    Py_DECREF(type_obj);
+    return NULL;
+#else
+    PyObject *super_type, *super, *func, *res;
+#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type)
+    super_type = __Pyx_GetBuiltinName(__pyx_n_s_super);
+#else
+    super_type = (PyObject*) &PySuper_Type;
+    (void) &__Pyx_GetBuiltinName;
+#endif
+    super = likely(super_type) ? __Pyx_PyObject_Call2Args(super_type, type_obj, type_obj) : NULL;
+#if CYTHON_COMPILING_IN_PYPY && !defined(PySuper_Type)
+    Py_XDECREF(super_type);
+#endif
+    if (unlikely(!super)) {
+        Py_CLEAR(type_obj);
+        goto done;
+    }
+    func = __Pyx_PyObject_GetAttrStrNoError(super, __pyx_n_s_init_subclass);
+    Py_DECREF(super);
+    if (likely(!func)) {
+        if (unlikely(PyErr_Occurred()))
+            Py_CLEAR(type_obj);
+        goto done;
+    }
+    res = __Pyx_PyObject_FastCallDict(func, NULL, 0, mkw);
+    Py_DECREF(func);
+    if (unlikely(!res))
+        Py_CLEAR(type_obj);
+    Py_XDECREF(res);
+done:
+    return type_obj;
+#endif
+}
+#endif
+static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
+                                      PyObject *dict, PyObject *mkw,
+                                      int calculate_metaclass, int allow_py2_metaclass) {
+    PyObject *result;
+    PyObject *owned_metaclass = NULL;
+    PyObject *margs[4] = {NULL, name, bases, dict};
+    if (allow_py2_metaclass) {
+        owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass);
+        if (owned_metaclass) {
+            metaclass = owned_metaclass;
+        } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) {
+            PyErr_Clear();
+        } else {
+            return NULL;
+        }
+    }
+    if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) {
+        metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
+        Py_XDECREF(owned_metaclass);
+        if (unlikely(!metaclass))
+            return NULL;
+        owned_metaclass = metaclass;
+    }
+    result = __Pyx_PyObject_FastCallDict(metaclass, margs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET,
+#if PY_VERSION_HEX < 0x030600A4
+        (metaclass == (PyObject*)&PyType_Type) ? NULL : mkw
+#else
+        mkw
+#endif
+    );
+    Py_XDECREF(owned_metaclass);
+#if PY_VERSION_HEX < 0x030600A4 && CYTHON_PEP487_INIT_SUBCLASS
+    if (likely(result) && likely(PyType_Check(result))) {
+        if (unlikely(__Pyx_SetNamesPEP487(result) < 0)) {
+            Py_CLEAR(result);
+        } else {
+            result = __Pyx_InitSubclassPEP487(result, mkw);
+        }
+    }
+#else
+    (void) &__Pyx_GetBuiltinName;
+#endif
+    return result;
+}
+
+/* GetNameInClass */
+static PyObject *__Pyx__GetNameInClass(PyObject *nmspace, PyObject *name) {
+    PyObject *result;
+    PyObject *dict;
+    assert(PyType_Check(nmspace));
+#if CYTHON_USE_TYPE_SLOTS
+    dict = ((PyTypeObject*)nmspace)->tp_dict;
+    Py_XINCREF(dict);
+#else
+    dict = PyObject_GetAttr(nmspace, __pyx_n_s_dict);
+#endif
+    if (likely(dict)) {
+        result = PyObject_GetItem(dict, name);
+        Py_DECREF(dict);
+        if (result) {
+            return result;
+        }
+    }
+    PyErr_Clear();
+    __Pyx_GetModuleGlobalNameUncached(result, name);
+    return result;
+}
+
+/* CLineInTraceback */
+#ifndef CYTHON_CLINE_IN_TRACEBACK
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
+    PyObject *use_cline;
+    PyObject *ptype, *pvalue, *ptraceback;
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject **cython_runtime_dict;
+#endif
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
+    if (unlikely(!__pyx_cython_runtime)) {
+        return c_line;
+    }
+    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+#if CYTHON_COMPILING_IN_CPYTHON
+    cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime);
+    if (likely(cython_runtime_dict)) {
+        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
+            use_cline, *cython_runtime_dict,
+            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback))
+    } else
+#endif
+    {
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback);
+      if (use_cline_obj) {
+        use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
+        Py_DECREF(use_cline_obj);
+      } else {
+        PyErr_Clear();
+        use_cline = NULL;
+      }
+    }
+    if (!use_cline) {
+        c_line = 0;
+        (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False);
+    }
+    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
+        c_line = 0;
+    }
+    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+    return c_line;
+}
+#endif
+
+/* CodeObjectCache */
+#if !CYTHON_COMPILING_IN_LIMITED_API
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+    int start = 0, mid = 0, end = count - 1;
+    if (end >= 0 && code_line > entries[end].code_line) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+#endif
+
+/* AddTraceback */
+#include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        (void) __pyx_cfilenm;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+    if (success) {
+        PyTraceBack_Here(
+            (struct _frame*)frame);
+    }
+    Py_XDECREF(frame);
+}
+#else
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = NULL;
+    PyObject *py_funcname = NULL;
+    #if PY_MAJOR_VERSION < 3
+    PyObject *py_srcfile = NULL;
+    py_srcfile = PyString_FromString(filename);
+    if (!py_srcfile) goto bad;
+    #endif
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        if (!py_funcname) goto bad;
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        if (!py_funcname) goto bad;
+        funcname = PyUnicode_AsUTF8(py_funcname);
+        if (!funcname) goto bad;
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        if (!py_funcname) goto bad;
+        #endif
+    }
+    #if PY_MAJOR_VERSION < 3
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    #else
+    py_code = PyCode_NewEmpty(filename, funcname, py_line);
+    #endif
+    Py_XDECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_funcname);
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_srcfile);
+    #endif
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject *ptype, *pvalue, *ptraceback;
+    if (c_line) {
+        c_line = __Pyx_CLineForTraceback(tstate, c_line);
+    }
+    py_code = __pyx_find_code_object(c_line ? -c_line : py_line);
+    if (!py_code) {
+        __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) {
+            /* If the code object creation fails, then we should clear the
+               fetched exception references and propagate the new exception */
+            Py_XDECREF(ptype);
+            Py_XDECREF(pvalue);
+            Py_XDECREF(ptraceback);
+            goto bad;
+        }
+        __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+        __pyx_insert_code_object(c_line ? -c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        tstate,            /*PyThreadState *tstate,*/
+        py_code,           /*PyCodeObject *code,*/
+        __pyx_d,    /*PyObject *globals,*/
+        0                  /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+#endif
+
+/* CIntFromPyVerify */
+#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_BOUNDTYPE(SCIP_BOUNDTYPE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_BOUNDTYPE neg_one = (SCIP_BOUNDTYPE) -1, const_zero = (SCIP_BOUNDTYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_BOUNDTYPE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_BOUNDTYPE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_BOUNDTYPE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_BOUNDTYPE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_BOUNDTYPE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_BOUNDTYPE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_BOUNDTYPE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_RESULT(SCIP_RESULT value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_RESULT neg_one = (SCIP_RESULT) -1, const_zero = (SCIP_RESULT) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_RESULT) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_RESULT) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_RESULT) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_RESULT) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_RESULT) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_RESULT),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_RESULT));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_PARAMSETTING(SCIP_PARAMSETTING value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_PARAMSETTING neg_one = (SCIP_PARAMSETTING) -1, const_zero = (SCIP_PARAMSETTING) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_PARAMSETTING) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_PARAMSETTING) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_PARAMSETTING) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_PARAMSETTING) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_PARAMSETTING) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_PARAMSETTING),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_PARAMSETTING));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_PARAMEMPHASIS(SCIP_PARAMEMPHASIS value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_PARAMEMPHASIS neg_one = (SCIP_PARAMEMPHASIS) -1, const_zero = (SCIP_PARAMEMPHASIS) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_PARAMEMPHASIS) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_PARAMEMPHASIS) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_PARAMEMPHASIS) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_PARAMEMPHASIS) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_PARAMEMPHASIS) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_PARAMEMPHASIS),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_PARAMEMPHASIS));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_STATUS(SCIP_STATUS value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_STATUS neg_one = (SCIP_STATUS) -1, const_zero = (SCIP_STATUS) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_STATUS) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_STATUS) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_STATUS) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_STATUS) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_STATUS) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_STATUS),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_STATUS));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_STAGE(SCIP_STAGE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_STAGE neg_one = (SCIP_STAGE) -1, const_zero = (SCIP_STAGE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_STAGE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_STAGE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_STAGE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_STAGE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_STAGE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_STAGE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_STAGE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_NODETYPE(SCIP_NODETYPE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_NODETYPE neg_one = (SCIP_NODETYPE) -1, const_zero = (SCIP_NODETYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_NODETYPE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_NODETYPE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_NODETYPE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_NODETYPE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_NODETYPE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_NODETYPE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_NODETYPE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_PROPTIMING(SCIP_PROPTIMING value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_PROPTIMING neg_one = (SCIP_PROPTIMING) -1, const_zero = (SCIP_PROPTIMING) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_PROPTIMING) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_PROPTIMING) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_PROPTIMING) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_PROPTIMING) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_PROPTIMING) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_PROPTIMING),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_PROPTIMING));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_PRESOLTIMING(SCIP_PRESOLTIMING value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_PRESOLTIMING neg_one = (SCIP_PRESOLTIMING) -1, const_zero = (SCIP_PRESOLTIMING) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_PRESOLTIMING) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_PRESOLTIMING) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_PRESOLTIMING) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_PRESOLTIMING) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_PRESOLTIMING) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_PRESOLTIMING),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_PRESOLTIMING));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_HEURTIMING(SCIP_HEURTIMING value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_HEURTIMING neg_one = (SCIP_HEURTIMING) -1, const_zero = (SCIP_HEURTIMING) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_HEURTIMING) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_HEURTIMING) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_HEURTIMING) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_HEURTIMING) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_HEURTIMING) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_HEURTIMING),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_HEURTIMING));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_EVENTTYPE(SCIP_EVENTTYPE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_EVENTTYPE neg_one = (SCIP_EVENTTYPE) -1, const_zero = (SCIP_EVENTTYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_EVENTTYPE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_EVENTTYPE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_EVENTTYPE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_EVENTTYPE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_EVENTTYPE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_EVENTTYPE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_EVENTTYPE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_LPSOLSTAT(SCIP_LPSOLSTAT value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_LPSOLSTAT neg_one = (SCIP_LPSOLSTAT) -1, const_zero = (SCIP_LPSOLSTAT) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_LPSOLSTAT) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_LPSOLSTAT) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_LPSOLSTAT) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_LPSOLSTAT) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_LPSOLSTAT) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_LPSOLSTAT),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_LPSOLSTAT));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_BRANCHDIR(SCIP_BRANCHDIR value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_BRANCHDIR neg_one = (SCIP_BRANCHDIR) -1, const_zero = (SCIP_BRANCHDIR) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_BRANCHDIR) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_BRANCHDIR) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_BRANCHDIR) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_BRANCHDIR) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_BRANCHDIR) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_BRANCHDIR),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_BRANCHDIR));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_BENDERSENFOTYPE(SCIP_BENDERSENFOTYPE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_BENDERSENFOTYPE neg_one = (SCIP_BENDERSENFOTYPE) -1, const_zero = (SCIP_BENDERSENFOTYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_BENDERSENFOTYPE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_BENDERSENFOTYPE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_BENDERSENFOTYPE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_BENDERSENFOTYPE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_BENDERSENFOTYPE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_BENDERSENFOTYPE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_BENDERSENFOTYPE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_ROWORIGINTYPE(SCIP_ROWORIGINTYPE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_ROWORIGINTYPE neg_one = (SCIP_ROWORIGINTYPE) -1, const_zero = (SCIP_ROWORIGINTYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_ROWORIGINTYPE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_ROWORIGINTYPE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_ROWORIGINTYPE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_ROWORIGINTYPE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_ROWORIGINTYPE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_ROWORIGINTYPE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_ROWORIGINTYPE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_RETCODE __Pyx_PyInt_As_SCIP_RETCODE(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_RETCODE neg_one = (SCIP_RETCODE) -1, const_zero = (SCIP_RETCODE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_RETCODE) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_RETCODE) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_RETCODE) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) (((((SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_RETCODE) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) (((((((SCIP_RETCODE)digits[2]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_RETCODE) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) (((((((((SCIP_RETCODE)digits[3]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[2]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_RETCODE) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_RETCODE) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_RETCODE, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_RETCODE) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_RETCODE, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_RETCODE) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) (((SCIP_RETCODE)-1)*(((((SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_RETCODE) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) ((((((SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_RETCODE) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) (((SCIP_RETCODE)-1)*(((((((SCIP_RETCODE)digits[2]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_RETCODE) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) ((((((((SCIP_RETCODE)digits[2]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_RETCODE) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) (((SCIP_RETCODE)-1)*(((((((((SCIP_RETCODE)digits[3]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[2]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_RETCODE) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RETCODE, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RETCODE) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_RETCODE) ((((((((((SCIP_RETCODE)digits[3]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[2]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[1]) << PyLong_SHIFT) | (SCIP_RETCODE)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_RETCODE) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_RETCODE, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_RETCODE) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_RETCODE, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_RETCODE val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_RETCODE) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_RETCODE) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_RETCODE) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_RETCODE) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_RETCODE) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_RETCODE) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_RETCODE) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_RETCODE) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_RETCODE) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_RETCODE) 1) << (sizeof(SCIP_RETCODE) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_RETCODE) -1;
+        }
+    } else {
+        SCIP_RETCODE val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_RETCODE) -1;
+        val = __Pyx_PyInt_As_SCIP_RETCODE(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_RETCODE");
+    return (SCIP_RETCODE) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_RETCODE");
+    return (SCIP_RETCODE) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const int neg_one = (int) -1, const_zero = (int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(int) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) {
+                                return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) {
+                                return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) {
+                                return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(int) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                                return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                                return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                                return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                                return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
+                                return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) {
+                                return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(int) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (int) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (int) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (int) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (int) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (int) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((int) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((int) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (int) -1;
+        }
+    } else {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(long) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) {
+                                return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) {
+                                return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) {
+                                return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (long) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(long) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                                return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                                return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                                return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                                return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
+                                return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) {
+                                return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(long) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            long val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (long) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (long) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (long) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (long) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (long) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((long) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((long) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (long) -1;
+        }
+    } else {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const long neg_one = (long) -1, const_zero = (long) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_RETCODE(SCIP_RETCODE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_RETCODE neg_one = (SCIP_RETCODE) -1, const_zero = (SCIP_RETCODE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_RETCODE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_RETCODE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_RETCODE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_RETCODE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_RETCODE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_RETCODE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_RETCODE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(size_t) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (size_t) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) {
+                                return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) {
+                                return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) {
+                                return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (size_t) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(size_t) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                                return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                                return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                                return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                                return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
+                                return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) {
+                                return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(size_t) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            size_t val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (size_t) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (size_t) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (size_t) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (size_t) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (size_t) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((size_t) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((size_t) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (size_t) -1;
+        }
+    } else {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to size_t");
+    return (size_t) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to size_t");
+    return (size_t) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_RESULT __Pyx_PyInt_As_SCIP_RESULT(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_RESULT neg_one = (SCIP_RESULT) -1, const_zero = (SCIP_RESULT) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_RESULT) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_RESULT, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_RESULT) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_RESULT) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) (((((SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_RESULT) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) (((((((SCIP_RESULT)digits[2]) << PyLong_SHIFT) | (SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_RESULT) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) (((((((((SCIP_RESULT)digits[3]) << PyLong_SHIFT) | (SCIP_RESULT)digits[2]) << PyLong_SHIFT) | (SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_RESULT) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_RESULT) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_RESULT, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_RESULT) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_RESULT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_RESULT) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) (((SCIP_RESULT)-1)*(((((SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_RESULT) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) ((((((SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_RESULT) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) (((SCIP_RESULT)-1)*(((((((SCIP_RESULT)digits[2]) << PyLong_SHIFT) | (SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_RESULT) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) ((((((((SCIP_RESULT)digits[2]) << PyLong_SHIFT) | (SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_RESULT) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) (((SCIP_RESULT)-1)*(((((((((SCIP_RESULT)digits[3]) << PyLong_SHIFT) | (SCIP_RESULT)digits[2]) << PyLong_SHIFT) | (SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_RESULT) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_RESULT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_RESULT) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_RESULT) ((((((((((SCIP_RESULT)digits[3]) << PyLong_SHIFT) | (SCIP_RESULT)digits[2]) << PyLong_SHIFT) | (SCIP_RESULT)digits[1]) << PyLong_SHIFT) | (SCIP_RESULT)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_RESULT) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_RESULT, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_RESULT) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_RESULT, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_RESULT val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_RESULT) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_RESULT) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_RESULT) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_RESULT) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_RESULT) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_RESULT) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_RESULT) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_RESULT) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_RESULT) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_RESULT) 1) << (sizeof(SCIP_RESULT) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_RESULT) -1;
+        }
+    } else {
+        SCIP_RESULT val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_RESULT) -1;
+        val = __Pyx_PyInt_As_SCIP_RESULT(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_RESULT");
+    return (SCIP_RESULT) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_RESULT");
+    return (SCIP_RESULT) -1;
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_LOCKTYPE(SCIP_LOCKTYPE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_LOCKTYPE neg_one = (SCIP_LOCKTYPE) -1, const_zero = (SCIP_LOCKTYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_LOCKTYPE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_LOCKTYPE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_LOCKTYPE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_LOCKTYPE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_LOCKTYPE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_LOCKTYPE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_LOCKTYPE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_OBJSENSE(SCIP_OBJSENSE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_OBJSENSE neg_one = (SCIP_OBJSENSE) -1, const_zero = (SCIP_OBJSENSE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_OBJSENSE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_OBJSENSE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_OBJSENSE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_OBJSENSE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_OBJSENSE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_OBJSENSE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_OBJSENSE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_BOUNDCHGTYPE(SCIP_BOUNDCHGTYPE value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_BOUNDCHGTYPE neg_one = (SCIP_BOUNDCHGTYPE) -1, const_zero = (SCIP_BOUNDCHGTYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_BOUNDCHGTYPE) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_BOUNDCHGTYPE) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_BOUNDCHGTYPE) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_BOUNDCHGTYPE) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_BOUNDCHGTYPE) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_BOUNDCHGTYPE),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_BOUNDCHGTYPE));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_SCIP_Longint(SCIP_Longint value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_Longint neg_one = (SCIP_Longint) -1, const_zero = (SCIP_Longint) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(SCIP_Longint) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(SCIP_Longint) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_Longint) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(SCIP_Longint) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(SCIP_Longint) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(SCIP_Longint),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(SCIP_Longint));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_PARAMSETTING __Pyx_PyInt_As_SCIP_PARAMSETTING(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_PARAMSETTING neg_one = (SCIP_PARAMSETTING) -1, const_zero = (SCIP_PARAMSETTING) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_PARAMSETTING) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_PARAMSETTING) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) (((((SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) (((((((SCIP_PARAMSETTING)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) (((((((((SCIP_PARAMSETTING)digits[3]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_PARAMSETTING) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_PARAMSETTING) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PARAMSETTING, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_PARAMSETTING) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PARAMSETTING, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) (((SCIP_PARAMSETTING)-1)*(((((SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) ((((((SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) (((SCIP_PARAMSETTING)-1)*(((((((SCIP_PARAMSETTING)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) ((((((((SCIP_PARAMSETTING)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) (((SCIP_PARAMSETTING)-1)*(((((((((SCIP_PARAMSETTING)digits[3]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_PARAMSETTING) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMSETTING, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMSETTING) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMSETTING) ((((((((((SCIP_PARAMSETTING)digits[3]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMSETTING)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_PARAMSETTING) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PARAMSETTING, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_PARAMSETTING) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PARAMSETTING, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_PARAMSETTING val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_PARAMSETTING) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_PARAMSETTING) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_PARAMSETTING) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_PARAMSETTING) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_PARAMSETTING) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_PARAMSETTING) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_PARAMSETTING) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_PARAMSETTING) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_PARAMSETTING) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_PARAMSETTING) 1) << (sizeof(SCIP_PARAMSETTING) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_PARAMSETTING) -1;
+        }
+    } else {
+        SCIP_PARAMSETTING val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_PARAMSETTING) -1;
+        val = __Pyx_PyInt_As_SCIP_PARAMSETTING(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_PARAMSETTING");
+    return (SCIP_PARAMSETTING) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_PARAMSETTING");
+    return (SCIP_PARAMSETTING) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const char neg_one = (char) -1, const_zero = (char) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(char) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (char) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) >= 2 * PyLong_SHIFT)) {
+                                return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) >= 3 * PyLong_SHIFT)) {
+                                return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) >= 4 * PyLong_SHIFT)) {
+                                return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (char) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(char) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(char) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(char) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) {
+                                return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) {
+                                return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) {
+                                return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) {
+                                return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) - 1 > 4 * PyLong_SHIFT)) {
+                                return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(char) - 1 > 4 * PyLong_SHIFT)) {
+                                return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(char) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(char) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            char val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (char) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (char) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (char) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (char) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (char) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(char) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((char) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(char) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((char) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((char) 1) << (sizeof(char) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (char) -1;
+        }
+    } else {
+        char val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (char) -1;
+        val = __Pyx_PyInt_As_char(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to char");
+    return (char) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to char");
+    return (char) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_BENDERSENFOTYPE __Pyx_PyInt_As_SCIP_BENDERSENFOTYPE(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_BENDERSENFOTYPE neg_one = (SCIP_BENDERSENFOTYPE) -1, const_zero = (SCIP_BENDERSENFOTYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_BENDERSENFOTYPE) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_BENDERSENFOTYPE) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) (((((SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) (((((((SCIP_BENDERSENFOTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) (((((((((SCIP_BENDERSENFOTYPE)digits[3]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_BENDERSENFOTYPE) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_BENDERSENFOTYPE) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_BENDERSENFOTYPE, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_BENDERSENFOTYPE) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_BENDERSENFOTYPE, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) (((SCIP_BENDERSENFOTYPE)-1)*(((((SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) ((((((SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) (((SCIP_BENDERSENFOTYPE)-1)*(((((((SCIP_BENDERSENFOTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) ((((((((SCIP_BENDERSENFOTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) (((SCIP_BENDERSENFOTYPE)-1)*(((((((((SCIP_BENDERSENFOTYPE)digits[3]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_BENDERSENFOTYPE) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BENDERSENFOTYPE, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BENDERSENFOTYPE) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_BENDERSENFOTYPE) ((((((((((SCIP_BENDERSENFOTYPE)digits[3]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_BENDERSENFOTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_BENDERSENFOTYPE) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_BENDERSENFOTYPE, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_BENDERSENFOTYPE) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_BENDERSENFOTYPE, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_BENDERSENFOTYPE val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_BENDERSENFOTYPE) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_BENDERSENFOTYPE) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_BENDERSENFOTYPE) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_BENDERSENFOTYPE) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_BENDERSENFOTYPE) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_BENDERSENFOTYPE) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_BENDERSENFOTYPE) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_BENDERSENFOTYPE) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_BENDERSENFOTYPE) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_BENDERSENFOTYPE) 1) << (sizeof(SCIP_BENDERSENFOTYPE) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_BENDERSENFOTYPE) -1;
+        }
+    } else {
+        SCIP_BENDERSENFOTYPE val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_BENDERSENFOTYPE) -1;
+        val = __Pyx_PyInt_As_SCIP_BENDERSENFOTYPE(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_BENDERSENFOTYPE");
+    return (SCIP_BENDERSENFOTYPE) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_BENDERSENFOTYPE");
+    return (SCIP_BENDERSENFOTYPE) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_PROPTIMING __Pyx_PyInt_As_SCIP_PROPTIMING(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_PROPTIMING neg_one = (SCIP_PROPTIMING) -1, const_zero = (SCIP_PROPTIMING) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_PROPTIMING) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_PROPTIMING) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_PROPTIMING) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) (((((SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_PROPTIMING) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) (((((((SCIP_PROPTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_PROPTIMING) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) (((((((((SCIP_PROPTIMING)digits[3]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_PROPTIMING) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_PROPTIMING) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PROPTIMING, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_PROPTIMING) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PROPTIMING, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) (((SCIP_PROPTIMING)-1)*(((((SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_PROPTIMING) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) ((((((SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) (((SCIP_PROPTIMING)-1)*(((((((SCIP_PROPTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_PROPTIMING) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) ((((((((SCIP_PROPTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) (((SCIP_PROPTIMING)-1)*(((((((((SCIP_PROPTIMING)digits[3]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_PROPTIMING) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PROPTIMING, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PROPTIMING) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_PROPTIMING) ((((((((((SCIP_PROPTIMING)digits[3]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PROPTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_PROPTIMING) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PROPTIMING, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_PROPTIMING) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PROPTIMING, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_PROPTIMING val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_PROPTIMING) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_PROPTIMING) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_PROPTIMING) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_PROPTIMING) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_PROPTIMING) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_PROPTIMING) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_PROPTIMING) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_PROPTIMING) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_PROPTIMING) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_PROPTIMING) 1) << (sizeof(SCIP_PROPTIMING) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_PROPTIMING) -1;
+        }
+    } else {
+        SCIP_PROPTIMING val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_PROPTIMING) -1;
+        val = __Pyx_PyInt_As_SCIP_PROPTIMING(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_PROPTIMING");
+    return (SCIP_PROPTIMING) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_PROPTIMING");
+    return (SCIP_PROPTIMING) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_PRESOLTIMING __Pyx_PyInt_As_SCIP_PRESOLTIMING(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_PRESOLTIMING neg_one = (SCIP_PRESOLTIMING) -1, const_zero = (SCIP_PRESOLTIMING) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_PRESOLTIMING) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_PRESOLTIMING) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) (((((SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) (((((((SCIP_PRESOLTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) (((((((((SCIP_PRESOLTIMING)digits[3]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_PRESOLTIMING) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_PRESOLTIMING) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PRESOLTIMING, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_PRESOLTIMING) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PRESOLTIMING, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) (((SCIP_PRESOLTIMING)-1)*(((((SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) ((((((SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) (((SCIP_PRESOLTIMING)-1)*(((((((SCIP_PRESOLTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) ((((((((SCIP_PRESOLTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) (((SCIP_PRESOLTIMING)-1)*(((((((((SCIP_PRESOLTIMING)digits[3]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_PRESOLTIMING) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PRESOLTIMING, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PRESOLTIMING) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_PRESOLTIMING) ((((((((((SCIP_PRESOLTIMING)digits[3]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[2]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[1]) << PyLong_SHIFT) | (SCIP_PRESOLTIMING)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_PRESOLTIMING) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PRESOLTIMING, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_PRESOLTIMING) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PRESOLTIMING, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_PRESOLTIMING val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_PRESOLTIMING) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_PRESOLTIMING) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_PRESOLTIMING) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_PRESOLTIMING) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_PRESOLTIMING) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_PRESOLTIMING) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_PRESOLTIMING) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_PRESOLTIMING) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_PRESOLTIMING) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_PRESOLTIMING) 1) << (sizeof(SCIP_PRESOLTIMING) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_PRESOLTIMING) -1;
+        }
+    } else {
+        SCIP_PRESOLTIMING val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_PRESOLTIMING) -1;
+        val = __Pyx_PyInt_As_SCIP_PRESOLTIMING(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_PRESOLTIMING");
+    return (SCIP_PRESOLTIMING) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_PRESOLTIMING");
+    return (SCIP_PRESOLTIMING) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(unsigned int) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (unsigned int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) {
+                                return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) {
+                                return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT)) {
+                                return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (unsigned int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(unsigned int) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
+                                return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
+                                return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
+                                return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
+                                return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) {
+                                return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) {
+                                return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(unsigned int) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            unsigned int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (unsigned int) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (unsigned int) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (unsigned int) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (unsigned int) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (unsigned int) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((unsigned int) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((unsigned int) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (unsigned int) -1;
+        }
+    } else {
+        unsigned int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned int) -1;
+        val = __Pyx_PyInt_As_unsigned_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to unsigned int");
+    return (unsigned int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to unsigned int");
+    return (unsigned int) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_BRANCHDIR __Pyx_PyInt_As_SCIP_BRANCHDIR(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_BRANCHDIR neg_one = (SCIP_BRANCHDIR) -1, const_zero = (SCIP_BRANCHDIR) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_BRANCHDIR) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_BRANCHDIR) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) (((((SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) (((((((SCIP_BRANCHDIR)digits[2]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) (((((((((SCIP_BRANCHDIR)digits[3]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[2]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_BRANCHDIR) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_BRANCHDIR) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_BRANCHDIR, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_BRANCHDIR) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_BRANCHDIR, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) (((SCIP_BRANCHDIR)-1)*(((((SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) ((((((SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) (((SCIP_BRANCHDIR)-1)*(((((((SCIP_BRANCHDIR)digits[2]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) ((((((((SCIP_BRANCHDIR)digits[2]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) (((SCIP_BRANCHDIR)-1)*(((((((((SCIP_BRANCHDIR)digits[3]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[2]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_BRANCHDIR) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_BRANCHDIR, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_BRANCHDIR) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_BRANCHDIR) ((((((((((SCIP_BRANCHDIR)digits[3]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[2]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[1]) << PyLong_SHIFT) | (SCIP_BRANCHDIR)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_BRANCHDIR) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_BRANCHDIR, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_BRANCHDIR) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_BRANCHDIR, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_BRANCHDIR val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_BRANCHDIR) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_BRANCHDIR) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_BRANCHDIR) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_BRANCHDIR) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_BRANCHDIR) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_BRANCHDIR) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_BRANCHDIR) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_BRANCHDIR) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_BRANCHDIR) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_BRANCHDIR) 1) << (sizeof(SCIP_BRANCHDIR) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_BRANCHDIR) -1;
+        }
+    } else {
+        SCIP_BRANCHDIR val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_BRANCHDIR) -1;
+        val = __Pyx_PyInt_As_SCIP_BRANCHDIR(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_BRANCHDIR");
+    return (SCIP_BRANCHDIR) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_BRANCHDIR");
+    return (SCIP_BRANCHDIR) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_EVENTTYPE __Pyx_PyInt_As_SCIP_EVENTTYPE(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_EVENTTYPE neg_one = (SCIP_EVENTTYPE) -1, const_zero = (SCIP_EVENTTYPE) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_EVENTTYPE) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_EVENTTYPE) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) (((((SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) (((((((SCIP_EVENTTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) (((((((((SCIP_EVENTTYPE)digits[3]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_EVENTTYPE) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_EVENTTYPE) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_EVENTTYPE, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_EVENTTYPE) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_EVENTTYPE, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) (((SCIP_EVENTTYPE)-1)*(((((SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) ((((((SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) (((SCIP_EVENTTYPE)-1)*(((((((SCIP_EVENTTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) ((((((((SCIP_EVENTTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) (((SCIP_EVENTTYPE)-1)*(((((((((SCIP_EVENTTYPE)digits[3]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_EVENTTYPE) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_EVENTTYPE, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_EVENTTYPE) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_EVENTTYPE) ((((((((((SCIP_EVENTTYPE)digits[3]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[2]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[1]) << PyLong_SHIFT) | (SCIP_EVENTTYPE)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_EVENTTYPE) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_EVENTTYPE, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_EVENTTYPE) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_EVENTTYPE, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_EVENTTYPE val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_EVENTTYPE) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_EVENTTYPE) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_EVENTTYPE) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_EVENTTYPE) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_EVENTTYPE) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_EVENTTYPE) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_EVENTTYPE) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_EVENTTYPE) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_EVENTTYPE) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_EVENTTYPE) 1) << (sizeof(SCIP_EVENTTYPE) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_EVENTTYPE) -1;
+        }
+    } else {
+        SCIP_EVENTTYPE val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_EVENTTYPE) -1;
+        val = __Pyx_PyInt_As_SCIP_EVENTTYPE(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_EVENTTYPE");
+    return (SCIP_EVENTTYPE) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_EVENTTYPE");
+    return (SCIP_EVENTTYPE) -1;
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_Longint __Pyx_PyInt_As_SCIP_Longint(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_Longint neg_one = (SCIP_Longint) -1, const_zero = (SCIP_Longint) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_Longint) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_Longint, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_Longint) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_Longint, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_Longint) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) (((((SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_Longint) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) (((((((SCIP_Longint)digits[2]) << PyLong_SHIFT) | (SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_Longint) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) (((((((((SCIP_Longint)digits[3]) << PyLong_SHIFT) | (SCIP_Longint)digits[2]) << PyLong_SHIFT) | (SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_Longint) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_Longint) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_Longint, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_Longint) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_Longint, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_Longint, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_Longint) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) (((SCIP_Longint)-1)*(((((SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_Longint) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) ((((((SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_Longint) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) (((SCIP_Longint)-1)*(((((((SCIP_Longint)digits[2]) << PyLong_SHIFT) | (SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_Longint) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) ((((((((SCIP_Longint)digits[2]) << PyLong_SHIFT) | (SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_Longint) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) (((SCIP_Longint)-1)*(((((((((SCIP_Longint)digits[3]) << PyLong_SHIFT) | (SCIP_Longint)digits[2]) << PyLong_SHIFT) | (SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_Longint) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_Longint, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_Longint) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_Longint) ((((((((((SCIP_Longint)digits[3]) << PyLong_SHIFT) | (SCIP_Longint)digits[2]) << PyLong_SHIFT) | (SCIP_Longint)digits[1]) << PyLong_SHIFT) | (SCIP_Longint)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_Longint) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_Longint, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_Longint) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_Longint, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_Longint val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_Longint) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_Longint) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_Longint) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_Longint) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_Longint) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_Longint) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_Longint) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_Longint) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_Longint) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_Longint) 1) << (sizeof(SCIP_Longint) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_Longint) -1;
+        }
+    } else {
+        SCIP_Longint val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_Longint) -1;
+        val = __Pyx_PyInt_As_SCIP_Longint(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_Longint");
+    return (SCIP_Longint) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_Longint");
+    return (SCIP_Longint) -1;
+}
+
+/* CIntToPy */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const char neg_one = (char) -1, const_zero = (char) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(char) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(char) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(char) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        return _PyLong_FromByteArray(bytes, sizeof(char),
+                                     little, !is_unsigned);
+#else
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(char));
+        if (!py_bytes) goto limited_bad;
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+/* CIntFromPy */
+static CYTHON_INLINE SCIP_PARAMEMPHASIS __Pyx_PyInt_As_SCIP_PARAMEMPHASIS(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const SCIP_PARAMEMPHASIS neg_one = (SCIP_PARAMEMPHASIS) -1, const_zero = (SCIP_PARAMEMPHASIS) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof(SCIP_PARAMEMPHASIS) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (SCIP_PARAMEMPHASIS) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+                goto raise_neg_overflow;
+            } else if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_DigitCount(x)) {
+                    case 2:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) >= 2 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) (((((SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0]));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) >= 3 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) (((((((SCIP_PARAMEMPHASIS)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0]));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) >= 4 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) (((((((((SCIP_PARAMEMPHASIS)digits[3]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0]));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (SCIP_PARAMEMPHASIS) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if ((sizeof(SCIP_PARAMEMPHASIS) <= sizeof(unsigned long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PARAMEMPHASIS, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_PARAMEMPHASIS) <= sizeof(unsigned PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PARAMEMPHASIS, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            if (__Pyx_PyLong_IsCompact(x)) {
+                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+            } else {
+                const digit* digits = __Pyx_PyLong_Digits(x);
+                assert(__Pyx_PyLong_DigitCount(x) > 1);
+                switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                    case -2:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) (((SCIP_PARAMEMPHASIS)-1)*(((((SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0])));
+                            }
+                        }
+                        break;
+                    case 2:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) > 1 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 2 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) ((((((SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0])));
+                            }
+                        }
+                        break;
+                    case -3:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) (((SCIP_PARAMEMPHASIS)-1)*(((((((SCIP_PARAMEMPHASIS)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0])));
+                            }
+                        }
+                        break;
+                    case 3:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) > 2 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 3 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) ((((((((SCIP_PARAMEMPHASIS)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0])));
+                            }
+                        }
+                        break;
+                    case -4:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) (((SCIP_PARAMEMPHASIS)-1)*(((((((((SCIP_PARAMEMPHASIS)digits[3]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0])));
+                            }
+                        }
+                        break;
+                    case 4:
+                        if ((8 * sizeof(SCIP_PARAMEMPHASIS) > 3 * PyLong_SHIFT)) {
+                            if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) {
+                                __PYX_VERIFY_RETURN_INT(SCIP_PARAMEMPHASIS, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                            } else if ((8 * sizeof(SCIP_PARAMEMPHASIS) - 1 > 4 * PyLong_SHIFT)) {
+                                return (SCIP_PARAMEMPHASIS) ((((((((((SCIP_PARAMEMPHASIS)digits[3]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[2]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[1]) << PyLong_SHIFT) | (SCIP_PARAMEMPHASIS)digits[0])));
+                            }
+                        }
+                        break;
+                }
+            }
+#endif
+            if ((sizeof(SCIP_PARAMEMPHASIS) <= sizeof(long))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PARAMEMPHASIS, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if ((sizeof(SCIP_PARAMEMPHASIS) <= sizeof(PY_LONG_LONG))) {
+                __PYX_VERIFY_RETURN_INT_EXC(SCIP_PARAMEMPHASIS, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+            SCIP_PARAMEMPHASIS val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+#if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+#endif
+            if (likely(v)) {
+                int ret = -1;
+#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                           bytes, sizeof(val),
+                                           is_little, !is_unsigned);
+#else
+                PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+                int bits, remaining_bits, is_negative = 0;
+                long idigit;
+                int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+                if (unlikely(!PyLong_CheckExact(v))) {
+                    PyObject *tmp = v;
+                    v = PyNumber_Long(v);
+                    assert(PyLong_CheckExact(v));
+                    Py_DECREF(tmp);
+                    if (unlikely(!v)) return (SCIP_PARAMEMPHASIS) -1;
+                }
+#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                if (Py_SIZE(x) == 0)
+                    return (SCIP_PARAMEMPHASIS) 0;
+                is_negative = Py_SIZE(x) < 0;
+#else
+                {
+                    int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                    if (unlikely(result < 0))
+                        return (SCIP_PARAMEMPHASIS) -1;
+                    is_negative = result == 1;
+                }
+#endif
+                if (is_unsigned && unlikely(is_negative)) {
+                    goto raise_neg_overflow;
+                } else if (is_negative) {
+                    stepval = PyNumber_Invert(v);
+                    if (unlikely(!stepval))
+                        return (SCIP_PARAMEMPHASIS) -1;
+                } else {
+                    stepval = __Pyx_NewRef(v);
+                }
+                val = (SCIP_PARAMEMPHASIS) 0;
+                mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+                shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+                for (bits = 0; bits < (int) sizeof(SCIP_PARAMEMPHASIS) * 8 - chunk_size; bits += chunk_size) {
+                    PyObject *tmp, *digit;
+                    digit = PyNumber_And(stepval, mask);
+                    if (unlikely(!digit)) goto done;
+                    idigit = PyLong_AsLong(digit);
+                    Py_DECREF(digit);
+                    if (unlikely(idigit < 0)) goto done;
+                    tmp = PyNumber_Rshift(stepval, shift);
+                    if (unlikely(!tmp)) goto done;
+                    Py_DECREF(stepval); stepval = tmp;
+                    val |= ((SCIP_PARAMEMPHASIS) idigit) << bits;
+                    #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+                    if (Py_SIZE(stepval) == 0)
+                        goto unpacking_done;
+                    #endif
+                }
+                idigit = PyLong_AsLong(stepval);
+                if (unlikely(idigit < 0)) goto done;
+                remaining_bits = ((int) sizeof(SCIP_PARAMEMPHASIS) * 8) - bits - (is_unsigned ? 0 : 1);
+                if (unlikely(idigit >= (1L << remaining_bits)))
+                    goto raise_overflow;
+                val |= ((SCIP_PARAMEMPHASIS) idigit) << bits;
+            #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000
+            unpacking_done:
+            #endif
+                if (!is_unsigned) {
+                    if (unlikely(val & (((SCIP_PARAMEMPHASIS) 1) << (sizeof(SCIP_PARAMEMPHASIS) * 8 - 1))))
+                        goto raise_overflow;
+                    if (is_negative)
+                        val = ~val;
+                }
+                ret = 0;
+            done:
+                Py_XDECREF(shift);
+                Py_XDECREF(mask);
+                Py_XDECREF(stepval);
+#endif
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+            return (SCIP_PARAMEMPHASIS) -1;
+        }
+    } else {
+        SCIP_PARAMEMPHASIS val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (SCIP_PARAMEMPHASIS) -1;
+        val = __Pyx_PyInt_As_SCIP_PARAMEMPHASIS(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to SCIP_PARAMEMPHASIS");
+    return (SCIP_PARAMEMPHASIS) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to SCIP_PARAMEMPHASIS");
+    return (SCIP_PARAMEMPHASIS) -1;
+}
+
+/* FormatTypeName */
+#if CYTHON_COMPILING_IN_LIMITED_API
+static __Pyx_TypeName
+__Pyx_PyType_GetName(PyTypeObject* tp)
+{
+    PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp,
+                                               __pyx_n_s_name_2);
+    if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) {
+        PyErr_Clear();
+        Py_XDECREF(name);
+        name = __Pyx_NewRef(__pyx_n_s__1188);
+    }
+    return name;
+}
+#endif
+
+/* FastTypeChecks */
+#if CYTHON_COMPILING_IN_CPYTHON
+static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
+    while (a) {
+        a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*);
+        if (a == b)
+            return 1;
+    }
+    return b == &PyBaseObject_Type;
+}
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (a == b) return 1;
+    mro = a->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(a, b);
+}
+static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) {
+    PyObject *mro;
+    if (cls == a || cls == b) return 1;
+    mro = cls->tp_mro;
+    if (likely(mro)) {
+        Py_ssize_t i, n;
+        n = PyTuple_GET_SIZE(mro);
+        for (i = 0; i < n; i++) {
+            PyObject *base = PyTuple_GET_ITEM(mro, i);
+            if (base == (PyObject *)a || base == (PyObject *)b)
+                return 1;
+        }
+        return 0;
+    }
+    return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b);
+}
+#if PY_MAJOR_VERSION == 2
+static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) {
+    PyObject *exception, *value, *tb;
+    int res;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&exception, &value, &tb);
+    res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0;
+    if (unlikely(res == -1)) {
+        PyErr_WriteUnraisable(err);
+        res = 0;
+    }
+    if (!res) {
+        res = PyObject_IsSubclass(err, exc_type2);
+        if (unlikely(res == -1)) {
+            PyErr_WriteUnraisable(err);
+            res = 0;
+        }
+    }
+    __Pyx_ErrRestore(exception, value, tb);
+    return res;
+}
+#else
+static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) {
+    if (exc_type1) {
+        return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2);
+    } else {
+        return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2);
+    }
+}
+#endif
+static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    assert(PyExceptionClass_Check(exc_type));
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    for (i=0; i= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_value = exc_info->exc_value;
+    exc_info->exc_value = *value;
+    if (tmp_value == NULL || tmp_value == Py_None) {
+        Py_XDECREF(tmp_value);
+        tmp_value = NULL;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+    } else {
+        tmp_type = (PyObject*) Py_TYPE(tmp_value);
+        Py_INCREF(tmp_type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback;
+        Py_XINCREF(tmp_tb);
+        #else
+        tmp_tb = PyException_GetTraceback(tmp_value);
+        #endif
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = *type;
+    exc_info->exc_value = *value;
+    exc_info->exc_traceback = *tb;
+  #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = *type;
+    tstate->exc_value = *value;
+    tstate->exc_traceback = *tb;
+  #endif
+    *type = tmp_type;
+    *value = tmp_value;
+    *tb = tmp_tb;
+}
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
+    PyErr_SetExcInfo(*type, *value, *tb);
+    *type = tmp_type;
+    *value = tmp_value;
+    *tb = tmp_tb;
+}
+#endif
+
+/* CoroutineBase */
+#include 
+#if PY_VERSION_HEX >= 0x030b00a6
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom)
+static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) {
+    PyObject *et, *ev, *tb;
+    PyObject *value = NULL;
+    CYTHON_UNUSED_VAR(__pyx_tstate);
+    __Pyx_ErrFetch(&et, &ev, &tb);
+    if (!et) {
+        Py_XDECREF(tb);
+        Py_XDECREF(ev);
+        Py_INCREF(Py_None);
+        *pvalue = Py_None;
+        return 0;
+    }
+    if (likely(et == PyExc_StopIteration)) {
+        if (!ev) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#if PY_VERSION_HEX >= 0x030300A0
+        else if (likely(__Pyx_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) {
+            value = ((PyStopIterationObject *)ev)->value;
+            Py_INCREF(value);
+            Py_DECREF(ev);
+        }
+#endif
+        else if (unlikely(PyTuple_Check(ev))) {
+            if (PyTuple_GET_SIZE(ev) >= 1) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+                value = PyTuple_GET_ITEM(ev, 0);
+                Py_INCREF(value);
+#else
+                value = PySequence_ITEM(ev, 0);
+#endif
+            } else {
+                Py_INCREF(Py_None);
+                value = Py_None;
+            }
+            Py_DECREF(ev);
+        }
+        else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) {
+            value = ev;
+        }
+        if (likely(value)) {
+            Py_XDECREF(tb);
+            Py_DECREF(et);
+            *pvalue = value;
+            return 0;
+        }
+    } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) {
+        __Pyx_ErrRestore(et, ev, tb);
+        return -1;
+    }
+    PyErr_NormalizeException(&et, &ev, &tb);
+    if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) {
+        __Pyx_ErrRestore(et, ev, tb);
+        return -1;
+    }
+    Py_XDECREF(tb);
+    Py_DECREF(et);
+#if PY_VERSION_HEX >= 0x030300A0
+    value = ((PyStopIterationObject *)ev)->value;
+    Py_INCREF(value);
+    Py_DECREF(ev);
+#else
+    {
+        PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args);
+        Py_DECREF(ev);
+        if (likely(args)) {
+            value = PySequence_GetItem(args, 0);
+            Py_DECREF(args);
+        }
+        if (unlikely(!value)) {
+            __Pyx_ErrRestore(NULL, NULL, NULL);
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+    }
+#endif
+    *pvalue = value;
+    return 0;
+}
+static CYTHON_INLINE
+void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) {
+#if PY_VERSION_HEX >= 0x030B00a4
+    Py_CLEAR(exc_state->exc_value);
+#else
+    PyObject *t, *v, *tb;
+    t = exc_state->exc_type;
+    v = exc_state->exc_value;
+    tb = exc_state->exc_traceback;
+    exc_state->exc_type = NULL;
+    exc_state->exc_value = NULL;
+    exc_state->exc_traceback = NULL;
+    Py_XDECREF(t);
+    Py_XDECREF(v);
+    Py_XDECREF(tb);
+#endif
+}
+#define __Pyx_Coroutine_AlreadyRunningError(gen)  (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL)
+static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) {
+    const char *msg;
+    CYTHON_MAYBE_UNUSED_VAR(gen);
+    if ((0)) {
+    #ifdef __Pyx_Coroutine_USED
+    } else if (__Pyx_Coroutine_Check((PyObject*)gen)) {
+        msg = "coroutine already executing";
+    #endif
+    #ifdef __Pyx_AsyncGen_USED
+    } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) {
+        msg = "async generator already executing";
+    #endif
+    } else {
+        msg = "generator already executing";
+    }
+    PyErr_SetString(PyExc_ValueError, msg);
+}
+#define __Pyx_Coroutine_NotStartedError(gen)  (__Pyx__Coroutine_NotStartedError(gen), (PyObject*)NULL)
+static void __Pyx__Coroutine_NotStartedError(PyObject *gen) {
+    const char *msg;
+    CYTHON_MAYBE_UNUSED_VAR(gen);
+    if ((0)) {
+    #ifdef __Pyx_Coroutine_USED
+    } else if (__Pyx_Coroutine_Check(gen)) {
+        msg = "can't send non-None value to a just-started coroutine";
+    #endif
+    #ifdef __Pyx_AsyncGen_USED
+    } else if (__Pyx_AsyncGen_CheckExact(gen)) {
+        msg = "can't send non-None value to a just-started async generator";
+    #endif
+    } else {
+        msg = "can't send non-None value to a just-started generator";
+    }
+    PyErr_SetString(PyExc_TypeError, msg);
+}
+#define __Pyx_Coroutine_AlreadyTerminatedError(gen, value, closing)  (__Pyx__Coroutine_AlreadyTerminatedError(gen, value, closing), (PyObject*)NULL)
+static void __Pyx__Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) {
+    CYTHON_MAYBE_UNUSED_VAR(gen);
+    CYTHON_MAYBE_UNUSED_VAR(closing);
+    #ifdef __Pyx_Coroutine_USED
+    if (!closing && __Pyx_Coroutine_Check(gen)) {
+        PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine");
+    } else
+    #endif
+    if (value) {
+        #ifdef __Pyx_AsyncGen_USED
+        if (__Pyx_AsyncGen_CheckExact(gen))
+            PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration);
+        else
+        #endif
+        PyErr_SetNone(PyExc_StopIteration);
+    }
+}
+static
+PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, int closing) {
+    __Pyx_PyThreadState_declare
+    PyThreadState *tstate;
+    __Pyx_ExcInfoStruct *exc_state;
+    PyObject *retval;
+    assert(!self->is_running);
+    if (unlikely(self->resume_label == 0)) {
+        if (unlikely(value && value != Py_None)) {
+            return __Pyx_Coroutine_NotStartedError((PyObject*)self);
+        }
+    }
+    if (unlikely(self->resume_label == -1)) {
+        return __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing);
+    }
+#if CYTHON_FAST_THREAD_STATE
+    __Pyx_PyThreadState_assign
+    tstate = __pyx_tstate;
+#else
+    tstate = __Pyx_PyThreadState_Current;
+#endif
+    exc_state = &self->gi_exc_state;
+    if (exc_state->exc_value) {
+        #if CYTHON_COMPILING_IN_PYPY
+        #else
+        PyObject *exc_tb;
+        #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON
+        exc_tb = PyException_GetTraceback(exc_state->exc_value);
+        #elif PY_VERSION_HEX >= 0x030B00a4
+        exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback;
+        #else
+        exc_tb = exc_state->exc_traceback;
+        #endif
+        if (exc_tb) {
+            PyTracebackObject *tb = (PyTracebackObject *) exc_tb;
+            PyFrameObject *f = tb->tb_frame;
+            assert(f->f_back == NULL);
+            #if PY_VERSION_HEX >= 0x030B00A1
+            f->f_back = PyThreadState_GetFrame(tstate);
+            #else
+            Py_XINCREF(tstate->frame);
+            f->f_back = tstate->frame;
+            #endif
+            #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON
+            Py_DECREF(exc_tb);
+            #endif
+        }
+        #endif
+    }
+#if CYTHON_USE_EXC_INFO_STACK
+    exc_state->previous_item = tstate->exc_info;
+    tstate->exc_info = exc_state;
+#else
+    if (exc_state->exc_type) {
+        __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback);
+    } else {
+        __Pyx_Coroutine_ExceptionClear(exc_state);
+        __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback);
+    }
+#endif
+    self->is_running = 1;
+    retval = self->body(self, tstate, value);
+    self->is_running = 0;
+#if CYTHON_USE_EXC_INFO_STACK
+    exc_state = &self->gi_exc_state;
+    tstate->exc_info = exc_state->previous_item;
+    exc_state->previous_item = NULL;
+    __Pyx_Coroutine_ResetFrameBackpointer(exc_state);
+#endif
+    return retval;
+}
+static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) {
+#if CYTHON_COMPILING_IN_PYPY
+    CYTHON_UNUSED_VAR(exc_state);
+#else
+    PyObject *exc_tb;
+    #if PY_VERSION_HEX >= 0x030B00a4
+    if (!exc_state->exc_value) return;
+    exc_tb = PyException_GetTraceback(exc_state->exc_value);
+    #else
+    exc_tb = exc_state->exc_traceback;
+    #endif
+    if (likely(exc_tb)) {
+        PyTracebackObject *tb = (PyTracebackObject *) exc_tb;
+        PyFrameObject *f = tb->tb_frame;
+        Py_CLEAR(f->f_back);
+        #if PY_VERSION_HEX >= 0x030B00a4
+        Py_DECREF(exc_tb);
+        #endif
+    }
+#endif
+}
+static CYTHON_INLINE
+PyObject *__Pyx_Coroutine_MethodReturn(PyObject* gen, PyObject *retval) {
+    CYTHON_MAYBE_UNUSED_VAR(gen);
+    if (unlikely(!retval)) {
+        __Pyx_PyThreadState_declare
+        __Pyx_PyThreadState_assign
+        if (!__Pyx_PyErr_Occurred()) {
+            PyObject *exc = PyExc_StopIteration;
+            #ifdef __Pyx_AsyncGen_USED
+            if (__Pyx_AsyncGen_CheckExact(gen))
+                exc = __Pyx_PyExc_StopAsyncIteration;
+            #endif
+            __Pyx_PyErr_SetNone(exc);
+        }
+    }
+    return retval;
+}
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3)
+static CYTHON_INLINE
+PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) {
+#if PY_VERSION_HEX <= 0x030A00A1
+    return _PyGen_Send(gen, arg);
+#else
+    PyObject *result;
+    if (PyIter_Send((PyObject*)gen, arg ? arg : Py_None, &result) == PYGEN_RETURN) {
+        if (PyAsyncGen_CheckExact(gen)) {
+            assert(result == Py_None);
+            PyErr_SetNone(PyExc_StopAsyncIteration);
+        }
+        else if (result == Py_None) {
+            PyErr_SetNone(PyExc_StopIteration);
+        }
+        else {
+#if PY_VERSION_HEX < 0x030d00A1
+            _PyGen_SetStopIterationValue(result);
+#else
+            if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) {
+                PyErr_SetObject(PyExc_StopIteration, result);
+            } else {
+                PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result);
+                if (likely(exc != NULL)) {
+                    PyErr_SetObject(PyExc_StopIteration, exc);
+                    Py_DECREF(exc);
+                }
+            }
+#endif
+        }
+        Py_DECREF(result);
+        result = NULL;
+    }
+    return result;
+#endif
+}
+#endif
+static CYTHON_INLINE
+PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) {
+    PyObject *ret;
+    PyObject *val = NULL;
+    __Pyx_Coroutine_Undelegate(gen);
+    __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val);
+    ret = __Pyx_Coroutine_SendEx(gen, val, 0);
+    Py_XDECREF(val);
+    return ret;
+}
+static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) {
+    PyObject *retval;
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self;
+    PyObject *yf = gen->yieldfrom;
+    if (unlikely(gen->is_running))
+        return __Pyx_Coroutine_AlreadyRunningError(gen);
+    if (yf) {
+        PyObject *ret;
+        gen->is_running = 1;
+        #ifdef __Pyx_Generator_USED
+        if (__Pyx_Generator_CheckExact(yf)) {
+            ret = __Pyx_Coroutine_Send(yf, value);
+        } else
+        #endif
+        #ifdef __Pyx_Coroutine_USED
+        if (__Pyx_Coroutine_Check(yf)) {
+            ret = __Pyx_Coroutine_Send(yf, value);
+        } else
+        #endif
+        #ifdef __Pyx_AsyncGen_USED
+        if (__pyx_PyAsyncGenASend_CheckExact(yf)) {
+            ret = __Pyx_async_gen_asend_send(yf, value);
+        } else
+        #endif
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3)
+        if (PyGen_CheckExact(yf)) {
+            ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value);
+        } else
+        #endif
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03050000 && defined(PyCoro_CheckExact) && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3)
+        if (PyCoro_CheckExact(yf)) {
+            ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value);
+        } else
+        #endif
+        {
+            if (value == Py_None)
+                ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf);
+            else
+                ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value);
+        }
+        gen->is_running = 0;
+        if (likely(ret)) {
+            return ret;
+        }
+        retval = __Pyx_Coroutine_FinishDelegation(gen);
+    } else {
+        retval = __Pyx_Coroutine_SendEx(gen, value, 0);
+    }
+    return __Pyx_Coroutine_MethodReturn(self, retval);
+}
+static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) {
+    PyObject *retval = NULL;
+    int err = 0;
+    #ifdef __Pyx_Generator_USED
+    if (__Pyx_Generator_CheckExact(yf)) {
+        retval = __Pyx_Coroutine_Close(yf);
+        if (!retval)
+            return -1;
+    } else
+    #endif
+    #ifdef __Pyx_Coroutine_USED
+    if (__Pyx_Coroutine_Check(yf)) {
+        retval = __Pyx_Coroutine_Close(yf);
+        if (!retval)
+            return -1;
+    } else
+    if (__Pyx_CoroutineAwait_CheckExact(yf)) {
+        retval = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf, NULL);
+        if (!retval)
+            return -1;
+    } else
+    #endif
+    #ifdef __Pyx_AsyncGen_USED
+    if (__pyx_PyAsyncGenASend_CheckExact(yf)) {
+        retval = __Pyx_async_gen_asend_close(yf, NULL);
+    } else
+    if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) {
+        retval = __Pyx_async_gen_athrow_close(yf, NULL);
+    } else
+    #endif
+    {
+        PyObject *meth;
+        gen->is_running = 1;
+        meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_n_s_close);
+        if (unlikely(!meth)) {
+            if (unlikely(PyErr_Occurred())) {
+                PyErr_WriteUnraisable(yf);
+            }
+        } else {
+            retval = __Pyx_PyObject_CallNoArg(meth);
+            Py_DECREF(meth);
+            if (unlikely(!retval))
+                err = -1;
+        }
+        gen->is_running = 0;
+    }
+    Py_XDECREF(retval);
+    return err;
+}
+static PyObject *__Pyx_Generator_Next(PyObject *self) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self;
+    PyObject *yf = gen->yieldfrom;
+    if (unlikely(gen->is_running))
+        return __Pyx_Coroutine_AlreadyRunningError(gen);
+    if (yf) {
+        PyObject *ret;
+        gen->is_running = 1;
+        #ifdef __Pyx_Generator_USED
+        if (__Pyx_Generator_CheckExact(yf)) {
+            ret = __Pyx_Generator_Next(yf);
+        } else
+        #endif
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3)
+        if (PyGen_CheckExact(yf)) {
+            ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL);
+        } else
+        #endif
+        #ifdef __Pyx_Coroutine_USED
+        if (__Pyx_Coroutine_Check(yf)) {
+            ret = __Pyx_Coroutine_Send(yf, Py_None);
+        } else
+        #endif
+            ret = __Pyx_PyObject_GetIterNextFunc(yf)(yf);
+        gen->is_running = 0;
+        if (likely(ret)) {
+            return ret;
+        }
+        return __Pyx_Coroutine_FinishDelegation(gen);
+    }
+    return __Pyx_Coroutine_SendEx(gen, Py_None, 0);
+}
+static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) {
+    CYTHON_UNUSED_VAR(arg);
+    return __Pyx_Coroutine_Close(self);
+}
+static PyObject *__Pyx_Coroutine_Close(PyObject *self) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    PyObject *retval, *raised_exception;
+    PyObject *yf = gen->yieldfrom;
+    int err = 0;
+    if (unlikely(gen->is_running))
+        return __Pyx_Coroutine_AlreadyRunningError(gen);
+    if (yf) {
+        Py_INCREF(yf);
+        err = __Pyx_Coroutine_CloseIter(gen, yf);
+        __Pyx_Coroutine_Undelegate(gen);
+        Py_DECREF(yf);
+    }
+    if (err == 0)
+        PyErr_SetNone(PyExc_GeneratorExit);
+    retval = __Pyx_Coroutine_SendEx(gen, NULL, 1);
+    if (unlikely(retval)) {
+        const char *msg;
+        Py_DECREF(retval);
+        if ((0)) {
+        #ifdef __Pyx_Coroutine_USED
+        } else if (__Pyx_Coroutine_Check(self)) {
+            msg = "coroutine ignored GeneratorExit";
+        #endif
+        #ifdef __Pyx_AsyncGen_USED
+        } else if (__Pyx_AsyncGen_CheckExact(self)) {
+#if PY_VERSION_HEX < 0x03060000
+            msg = "async generator ignored GeneratorExit - might require Python 3.6+ finalisation (PEP 525)";
+#else
+            msg = "async generator ignored GeneratorExit";
+#endif
+        #endif
+        } else {
+            msg = "generator ignored GeneratorExit";
+        }
+        PyErr_SetString(PyExc_RuntimeError, msg);
+        return NULL;
+    }
+    raised_exception = PyErr_Occurred();
+    if (likely(!raised_exception || __Pyx_PyErr_GivenExceptionMatches2(raised_exception, PyExc_GeneratorExit, PyExc_StopIteration))) {
+        if (raised_exception) PyErr_Clear();
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+    return NULL;
+}
+static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb,
+                                        PyObject *args, int close_on_genexit) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    PyObject *yf = gen->yieldfrom;
+    if (unlikely(gen->is_running))
+        return __Pyx_Coroutine_AlreadyRunningError(gen);
+    if (yf) {
+        PyObject *ret;
+        Py_INCREF(yf);
+        if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) {
+            int err = __Pyx_Coroutine_CloseIter(gen, yf);
+            Py_DECREF(yf);
+            __Pyx_Coroutine_Undelegate(gen);
+            if (err < 0)
+                return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0));
+            goto throw_here;
+        }
+        gen->is_running = 1;
+        if (0
+        #ifdef __Pyx_Generator_USED
+            || __Pyx_Generator_CheckExact(yf)
+        #endif
+        #ifdef __Pyx_Coroutine_USED
+            || __Pyx_Coroutine_Check(yf)
+        #endif
+            ) {
+            ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit);
+        #ifdef __Pyx_Coroutine_USED
+        } else if (__Pyx_CoroutineAwait_CheckExact(yf)) {
+            ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit);
+        #endif
+        } else {
+            PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_n_s_throw);
+            if (unlikely(!meth)) {
+                Py_DECREF(yf);
+                if (unlikely(PyErr_Occurred())) {
+                    gen->is_running = 0;
+                    return NULL;
+                }
+                __Pyx_Coroutine_Undelegate(gen);
+                gen->is_running = 0;
+                goto throw_here;
+            }
+            if (likely(args)) {
+                ret = __Pyx_PyObject_Call(meth, args, NULL);
+            } else {
+                PyObject *cargs[4] = {NULL, typ, val, tb};
+                ret = __Pyx_PyObject_FastCall(meth, cargs+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET);
+            }
+            Py_DECREF(meth);
+        }
+        gen->is_running = 0;
+        Py_DECREF(yf);
+        if (!ret) {
+            ret = __Pyx_Coroutine_FinishDelegation(gen);
+        }
+        return __Pyx_Coroutine_MethodReturn(self, ret);
+    }
+throw_here:
+    __Pyx_Raise(typ, val, tb, NULL);
+    return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0));
+}
+static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) {
+    PyObject *typ;
+    PyObject *val = NULL;
+    PyObject *tb = NULL;
+    if (unlikely(!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)))
+        return NULL;
+    return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1);
+}
+static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) {
+#if PY_VERSION_HEX >= 0x030B00a4
+    Py_VISIT(exc_state->exc_value);
+#else
+    Py_VISIT(exc_state->exc_type);
+    Py_VISIT(exc_state->exc_value);
+    Py_VISIT(exc_state->exc_traceback);
+#endif
+    return 0;
+}
+static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) {
+    Py_VISIT(gen->closure);
+    Py_VISIT(gen->classobj);
+    Py_VISIT(gen->yieldfrom);
+    return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg);
+}
+static int __Pyx_Coroutine_clear(PyObject *self) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    Py_CLEAR(gen->closure);
+    Py_CLEAR(gen->classobj);
+    Py_CLEAR(gen->yieldfrom);
+    __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state);
+#ifdef __Pyx_AsyncGen_USED
+    if (__Pyx_AsyncGen_CheckExact(self)) {
+        Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer);
+    }
+#endif
+    Py_CLEAR(gen->gi_code);
+    Py_CLEAR(gen->gi_frame);
+    Py_CLEAR(gen->gi_name);
+    Py_CLEAR(gen->gi_qualname);
+    Py_CLEAR(gen->gi_modulename);
+    return 0;
+}
+static void __Pyx_Coroutine_dealloc(PyObject *self) {
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    PyObject_GC_UnTrack(gen);
+    if (gen->gi_weakreflist != NULL)
+        PyObject_ClearWeakRefs(self);
+    if (gen->resume_label >= 0) {
+        PyObject_GC_Track(self);
+#if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE
+        if (unlikely(PyObject_CallFinalizerFromDealloc(self)))
+#else
+        Py_TYPE(gen)->tp_del(self);
+        if (unlikely(Py_REFCNT(self) > 0))
+#endif
+        {
+            return;
+        }
+        PyObject_GC_UnTrack(self);
+    }
+#ifdef __Pyx_AsyncGen_USED
+    if (__Pyx_AsyncGen_CheckExact(self)) {
+        /* We have to handle this case for asynchronous generators
+           right here, because this code has to be between UNTRACK
+           and GC_Del. */
+        Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer);
+    }
+#endif
+    __Pyx_Coroutine_clear(self);
+    __Pyx_PyHeapTypeObject_GC_Del(gen);
+}
+static void __Pyx_Coroutine_del(PyObject *self) {
+    PyObject *error_type, *error_value, *error_traceback;
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+    __Pyx_PyThreadState_declare
+    if (gen->resume_label < 0) {
+        return;
+    }
+#if !CYTHON_USE_TP_FINALIZE
+    assert(self->ob_refcnt == 0);
+    __Pyx_SET_REFCNT(self, 1);
+#endif
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&error_type, &error_value, &error_traceback);
+#ifdef __Pyx_AsyncGen_USED
+    if (__Pyx_AsyncGen_CheckExact(self)) {
+        __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self;
+        PyObject *finalizer = agen->ag_finalizer;
+        if (finalizer && !agen->ag_closed) {
+            PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self);
+            if (unlikely(!res)) {
+                PyErr_WriteUnraisable(self);
+            } else {
+                Py_DECREF(res);
+            }
+            __Pyx_ErrRestore(error_type, error_value, error_traceback);
+            return;
+        }
+    }
+#endif
+    if (unlikely(gen->resume_label == 0 && !error_value)) {
+#ifdef __Pyx_Coroutine_USED
+#ifdef __Pyx_Generator_USED
+    if (!__Pyx_Generator_CheckExact(self))
+#endif
+        {
+        PyObject_GC_UnTrack(self);
+#if PY_MAJOR_VERSION >= 3  || defined(PyErr_WarnFormat)
+        if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0))
+            PyErr_WriteUnraisable(self);
+#else
+        {PyObject *msg;
+        char *cmsg;
+        #if CYTHON_COMPILING_IN_PYPY
+        msg = NULL;
+        cmsg = (char*) "coroutine was never awaited";
+        #else
+        char *cname;
+        PyObject *qualname;
+        qualname = gen->gi_qualname;
+        cname = PyString_AS_STRING(qualname);
+        msg = PyString_FromFormat("coroutine '%.50s' was never awaited", cname);
+        if (unlikely(!msg)) {
+            PyErr_Clear();
+            cmsg = (char*) "coroutine was never awaited";
+        } else {
+            cmsg = PyString_AS_STRING(msg);
+        }
+        #endif
+        if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, cmsg, 1) < 0))
+            PyErr_WriteUnraisable(self);
+        Py_XDECREF(msg);}
+#endif
+        PyObject_GC_Track(self);
+        }
+#endif
+    } else {
+        PyObject *res = __Pyx_Coroutine_Close(self);
+        if (unlikely(!res)) {
+            if (PyErr_Occurred())
+                PyErr_WriteUnraisable(self);
+        } else {
+            Py_DECREF(res);
+        }
+    }
+    __Pyx_ErrRestore(error_type, error_value, error_traceback);
+#if !CYTHON_USE_TP_FINALIZE
+    assert(Py_REFCNT(self) > 0);
+    if (likely(--self->ob_refcnt == 0)) {
+        return;
+    }
+    {
+        Py_ssize_t refcnt = Py_REFCNT(self);
+        _Py_NewReference(self);
+        __Pyx_SET_REFCNT(self, refcnt);
+    }
+#if CYTHON_COMPILING_IN_CPYTHON
+    assert(PyType_IS_GC(Py_TYPE(self)) &&
+           _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
+    _Py_DEC_REFTOTAL;
+#endif
+#ifdef COUNT_ALLOCS
+    --Py_TYPE(self)->tp_frees;
+    --Py_TYPE(self)->tp_allocs;
+#endif
+#endif
+}
+static PyObject *
+__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context)
+{
+    PyObject *name = self->gi_name;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!name)) name = Py_None;
+    Py_INCREF(name);
+    return name;
+}
+static int
+__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__name__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(self->gi_name, value);
+    return 0;
+}
+static PyObject *
+__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context)
+{
+    PyObject *name = self->gi_qualname;
+    CYTHON_UNUSED_VAR(context);
+    if (unlikely(!name)) name = Py_None;
+    Py_INCREF(name);
+    return name;
+}
+static int
+__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context)
+{
+    CYTHON_UNUSED_VAR(context);
+#if PY_MAJOR_VERSION >= 3
+    if (unlikely(value == NULL || !PyUnicode_Check(value)))
+#else
+    if (unlikely(value == NULL || !PyString_Check(value)))
+#endif
+    {
+        PyErr_SetString(PyExc_TypeError,
+                        "__qualname__ must be set to a string object");
+        return -1;
+    }
+    Py_INCREF(value);
+    __Pyx_Py_XDECREF_SET(self->gi_qualname, value);
+    return 0;
+}
+static PyObject *
+__Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context)
+{
+    PyObject *frame = self->gi_frame;
+    CYTHON_UNUSED_VAR(context);
+    if (!frame) {
+        if (unlikely(!self->gi_code)) {
+            Py_RETURN_NONE;
+        }
+        frame = (PyObject *) PyFrame_New(
+            PyThreadState_Get(),            /*PyThreadState *tstate,*/
+            (PyCodeObject*) self->gi_code,  /*PyCodeObject *code,*/
+            __pyx_d,                 /*PyObject *globals,*/
+            0                               /*PyObject *locals*/
+        );
+        if (unlikely(!frame))
+            return NULL;
+        self->gi_frame = frame;
+    }
+    Py_INCREF(frame);
+    return frame;
+}
+static __pyx_CoroutineObject *__Pyx__Coroutine_New(
+            PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure,
+            PyObject *name, PyObject *qualname, PyObject *module_name) {
+    __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type);
+    if (unlikely(!gen))
+        return NULL;
+    return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name);
+}
+static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit(
+            __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure,
+            PyObject *name, PyObject *qualname, PyObject *module_name) {
+    gen->body = body;
+    gen->closure = closure;
+    Py_XINCREF(closure);
+    gen->is_running = 0;
+    gen->resume_label = 0;
+    gen->classobj = NULL;
+    gen->yieldfrom = NULL;
+    #if PY_VERSION_HEX >= 0x030B00a4
+    gen->gi_exc_state.exc_value = NULL;
+    #else
+    gen->gi_exc_state.exc_type = NULL;
+    gen->gi_exc_state.exc_value = NULL;
+    gen->gi_exc_state.exc_traceback = NULL;
+    #endif
+#if CYTHON_USE_EXC_INFO_STACK
+    gen->gi_exc_state.previous_item = NULL;
+#endif
+    gen->gi_weakreflist = NULL;
+    Py_XINCREF(qualname);
+    gen->gi_qualname = qualname;
+    Py_XINCREF(name);
+    gen->gi_name = name;
+    Py_XINCREF(module_name);
+    gen->gi_modulename = module_name;
+    Py_XINCREF(code);
+    gen->gi_code = code;
+    gen->gi_frame = NULL;
+    PyObject_GC_Track(gen);
+    return gen;
+}
+
+/* PatchModuleWithCoroutine */
+static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) {
+#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+    int result;
+    PyObject *globals, *result_obj;
+    globals = PyDict_New();  if (unlikely(!globals)) goto ignore;
+    result = PyDict_SetItemString(globals, "_cython_coroutine_type",
+    #ifdef __Pyx_Coroutine_USED
+        (PyObject*)__pyx_CoroutineType);
+    #else
+        Py_None);
+    #endif
+    if (unlikely(result < 0)) goto ignore;
+    result = PyDict_SetItemString(globals, "_cython_generator_type",
+    #ifdef __Pyx_Generator_USED
+        (PyObject*)__pyx_GeneratorType);
+    #else
+        Py_None);
+    #endif
+    if (unlikely(result < 0)) goto ignore;
+    if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore;
+    if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore;
+    result_obj = PyRun_String(py_code, Py_file_input, globals, globals);
+    if (unlikely(!result_obj)) goto ignore;
+    Py_DECREF(result_obj);
+    Py_DECREF(globals);
+    return module;
+ignore:
+    Py_XDECREF(globals);
+    PyErr_WriteUnraisable(module);
+    if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) {
+        Py_DECREF(module);
+        module = NULL;
+    }
+#else
+    py_code++;
+#endif
+    return module;
+}
+
+/* PatchGeneratorABC */
+#ifndef CYTHON_REGISTER_ABCS
+#define CYTHON_REGISTER_ABCS 1
+#endif
+#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+static PyObject* __Pyx_patch_abc_module(PyObject *module);
+static PyObject* __Pyx_patch_abc_module(PyObject *module) {
+    module = __Pyx_Coroutine_patch_module(
+        module, ""
+"if _cython_generator_type is not None:\n"
+"    try: Generator = _module.Generator\n"
+"    except AttributeError: pass\n"
+"    else: Generator.register(_cython_generator_type)\n"
+"if _cython_coroutine_type is not None:\n"
+"    try: Coroutine = _module.Coroutine\n"
+"    except AttributeError: pass\n"
+"    else: Coroutine.register(_cython_coroutine_type)\n"
+    );
+    return module;
+}
+#endif
+static int __Pyx_patch_abc(void) {
+#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+    static int abc_patched = 0;
+    if (CYTHON_REGISTER_ABCS && !abc_patched) {
+        PyObject *module;
+        module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections");
+        if (unlikely(!module)) {
+            PyErr_WriteUnraisable(NULL);
+            if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning,
+                    ((PY_MAJOR_VERSION >= 3) ?
+                        "Cython module failed to register with collections.abc module" :
+                        "Cython module failed to register with collections module"), 1) < 0)) {
+                return -1;
+            }
+        } else {
+            module = __Pyx_patch_abc_module(module);
+            abc_patched = 1;
+            if (unlikely(!module))
+                return -1;
+            Py_DECREF(module);
+        }
+        module = PyImport_ImportModule("backports_abc");
+        if (module) {
+            module = __Pyx_patch_abc_module(module);
+            Py_XDECREF(module);
+        }
+        if (!module) {
+            PyErr_Clear();
+        }
+    }
+#else
+    if ((0)) __Pyx_Coroutine_patch_module(NULL, NULL);
+#endif
+    return 0;
+}
+
+/* Generator */
+static PyMethodDef __pyx_Generator_methods[] = {
+    {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O,
+     (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")},
+    {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS,
+     (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")},
+    {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS,
+     (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")},
+    {0, 0, 0, 0}
+};
+static PyMemberDef __pyx_Generator_memberlist[] = {
+    {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL},
+    {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY,
+     (char*) PyDoc_STR("object being iterated by 'yield from', or None")},
+    {(char*) "gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL},
+    {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0},
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0},
+#endif
+    {0, 0, 0, 0, 0}
+};
+static PyGetSetDef __pyx_Generator_getsets[] = {
+    {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name,
+     (char*) PyDoc_STR("name of the generator"), 0},
+    {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname,
+     (char*) PyDoc_STR("qualified name of the generator"), 0},
+    {(char *) "gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL,
+     (char*) PyDoc_STR("Frame of the generator"), 0},
+    {0, 0, 0, 0, 0}
+};
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_GeneratorType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc},
+    {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse},
+    {Py_tp_iter, (void *)PyObject_SelfIter},
+    {Py_tp_iternext, (void *)__Pyx_Generator_Next},
+    {Py_tp_methods, (void *)__pyx_Generator_methods},
+    {Py_tp_members, (void *)__pyx_Generator_memberlist},
+    {Py_tp_getset, (void *)__pyx_Generator_getsets},
+    {Py_tp_getattro, (void *) __Pyx_PyObject_GenericGetAttrNoDict},
+#if CYTHON_USE_TP_FINALIZE
+    {Py_tp_finalize, (void *)__Pyx_Coroutine_del},
+#endif
+    {0, 0},
+};
+static PyType_Spec __pyx_GeneratorType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "generator",
+    sizeof(__pyx_CoroutineObject),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,
+    __pyx_GeneratorType_slots
+};
+#else
+static PyTypeObject __pyx_GeneratorType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    __PYX_TYPE_MODULE_PREFIX "generator",
+    sizeof(__pyx_CoroutineObject),
+    0,
+    (destructor) __Pyx_Coroutine_dealloc,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE,
+    0,
+    (traverseproc) __Pyx_Coroutine_traverse,
+    0,
+    0,
+    offsetof(__pyx_CoroutineObject, gi_weakreflist),
+    0,
+    (iternextfunc) __Pyx_Generator_Next,
+    __pyx_Generator_methods,
+    __pyx_Generator_memberlist,
+    __pyx_Generator_getsets,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+#if CYTHON_USE_TP_FINALIZE
+    0,
+#else
+    __Pyx_Coroutine_del,
+#endif
+    0,
+#if CYTHON_USE_TP_FINALIZE
+    __Pyx_Coroutine_del,
+#elif PY_VERSION_HEX >= 0x030400a1
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,
+#endif
+};
+#endif
+static int __pyx_Generator_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_GeneratorType_spec, NULL);
+#else
+    CYTHON_UNUSED_VAR(module);
+    __pyx_GeneratorType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+    __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter;
+    __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type);
+#endif
+    if (unlikely(!__pyx_GeneratorType)) {
+        return -1;
+    }
+    return 0;
+}
+
+/* CheckBinaryVersion */
+static unsigned long __Pyx_get_runtime_version(void) {
+#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4
+    return Py_Version & ~0xFFUL;
+#else
+    const char* rt_version = Py_GetVersion();
+    unsigned long version = 0;
+    unsigned long factor = 0x01000000UL;
+    unsigned int digit = 0;
+    int i = 0;
+    while (factor) {
+        while ('0' <= rt_version[i] && rt_version[i] <= '9') {
+            digit = digit * 10 + (unsigned int) (rt_version[i] - '0');
+            ++i;
+        }
+        version += factor * digit;
+        if (rt_version[i] != '.')
+            break;
+        digit = 0;
+        factor >>= 8;
+        ++i;
+    }
+    return version;
+#endif
+}
+static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) {
+    const unsigned long MAJOR_MINOR = 0xFFFF0000UL;
+    if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR))
+        return 0;
+    if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR)))
+        return 1;
+    {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compile time Python version %d.%d "
+                      "of module '%.100s' "
+                      "%s "
+                      "runtime version %d.%d",
+                       (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF),
+                       __Pyx_MODULE_NAME,
+                       (allow_newer) ? "was newer than" : "does not match",
+                       (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF)
+       );
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+}
+
+/* InitStrings */
+#if PY_MAJOR_VERSION >= 3
+static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) {
+    if (t.is_unicode | t.is_str) {
+        if (t.intern) {
+            *str = PyUnicode_InternFromString(t.s);
+        } else if (t.encoding) {
+            *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL);
+        } else {
+            *str = PyUnicode_FromStringAndSize(t.s, t.n - 1);
+        }
+    } else {
+        *str = PyBytes_FromStringAndSize(t.s, t.n - 1);
+    }
+    if (!*str)
+        return -1;
+    if (PyObject_Hash(*str) == -1)
+        return -1;
+    return 0;
+}
+#endif
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION >= 3
+        __Pyx_InitString(*t, t->p);
+        #else
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } else {
+            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
+        }
+        if (!*t->p)
+            return -1;
+        if (PyObject_Hash(*t->p) == -1)
+            return -1;
+        #endif
+        ++t;
+    }
+    return 0;
+}
+
+#include 
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
+}
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#if !CYTHON_PEP393_ENABLED
+static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    char* defenc_c;
+    PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+    if (!defenc) return NULL;
+    defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    {
+        char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+        char* c;
+        for (c = defenc_c; c < end; c++) {
+            if ((unsigned char) (*c) >= 128) {
+                PyUnicode_AsASCIIString(o);
+                return NULL;
+            }
+        }
+    }
+#endif
+    *length = PyBytes_GET_SIZE(defenc);
+    return defenc_c;
+}
+#else
+static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    if (likely(PyUnicode_IS_ASCII(o))) {
+        *length = PyUnicode_GET_LENGTH(o);
+        return PyUnicode_AsUTF8(o);
+    } else {
+        PyUnicode_AsASCIIString(o);
+        return NULL;
+    }
+#else
+    return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+}
+#endif
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+        return __Pyx_PyUnicode_AsStringAndSize(o, length);
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
+    int retval;
+    if (unlikely(!x)) return -1;
+    retval = __Pyx_PyObject_IsTrue(x);
+    Py_DECREF(x);
+    return retval;
+}
+static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
+#if PY_MAJOR_VERSION >= 3
+    if (PyLong_Check(result)) {
+        if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
+            Py_DECREF(result);
+            return NULL;
+        }
+        __Pyx_DECREF_TypeName(result_type_name);
+        return result;
+    }
+#endif
+    PyErr_Format(PyExc_TypeError,
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
+    Py_DECREF(result);
+    return NULL;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_Check(x) || PyLong_Check(x)))
+#else
+  if (likely(PyLong_Check(x)))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = m->nb_long(x);
+  }
+  #else
+  if (likely(m && m->nb_int)) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  #endif
+#else
+  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
+    res = PyNumber_Int(x);
+  }
+#endif
+  if (likely(res)) {
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
+#else
+    if (unlikely(!PyLong_CheckExact(res))) {
+#endif
+        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(b);
+  }
+#endif
+  if (likely(PyLong_CheckExact(b))) {
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
+    } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+      }
+    }
+    #endif
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) {
+  if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) {
+    return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o);
+#if PY_MAJOR_VERSION < 3
+  } else if (likely(PyInt_CheckExact(o))) {
+    return PyInt_AS_LONG(o);
+#endif
+  } else {
+    Py_ssize_t ival;
+    PyObject *x;
+    x = PyNumber_Index(o);
+    if (!x) return -1;
+    ival = PyInt_AsLong(x);
+    Py_DECREF(x);
+    return ival;
+  }
+}
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
+  return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+/* #### Code section: utility_code_pragmas_end ### */
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+
+
+/* #### Code section: end ### */
+#endif /* Py_PYTHON_H */
diff --git a/src/pyscipopt/scip.pxd b/src/pyscipopt/scip.pxd
new file mode 100644
index 0000000..f6fe8e8
--- /dev/null
+++ b/src/pyscipopt/scip.pxd
@@ -0,0 +1,1961 @@
+##@file scip.pxd
+#@brief holding prototype of the SCIP public functions to use them in PySCIPOpt
+cdef extern from "scip/scip.h":
+    # SCIP internal types
+    ctypedef int SCIP_RETCODE 
+    cdef extern from "scip/type_retcode.h":
+        SCIP_RETCODE SCIP_OKAY               
+        SCIP_RETCODE SCIP_ERROR              
+        SCIP_RETCODE SCIP_NOMEMORY           
+        SCIP_RETCODE SCIP_READERROR          
+        SCIP_RETCODE SCIP_WRITEERROR         
+        SCIP_RETCODE SCIP_NOFILE             
+        SCIP_RETCODE SCIP_FILECREATEERROR    
+        SCIP_RETCODE SCIP_LPERROR            
+        SCIP_RETCODE SCIP_NOPROBLEM          
+        SCIP_RETCODE SCIP_INVALIDCALL        
+        SCIP_RETCODE SCIP_INVALIDDATA        
+        SCIP_RETCODE SCIP_INVALIDRESULT      
+        SCIP_RETCODE SCIP_PLUGINNOTFOUND     
+        SCIP_RETCODE SCIP_PARAMETERUNKNOWN   
+        SCIP_RETCODE SCIP_PARAMETERWRONGTYPE 
+        SCIP_RETCODE SCIP_PARAMETERWRONGVAL  
+        SCIP_RETCODE SCIP_KEYALREADYEXISTING 
+        SCIP_RETCODE SCIP_MAXDEPTHLEVEL      
+
+    ctypedef int SCIP_VARTYPE
+    cdef extern from "scip/type_var.h":
+        SCIP_VARTYPE SCIP_VARTYPE_BINARY     
+        SCIP_VARTYPE SCIP_VARTYPE_INTEGER    
+        SCIP_VARTYPE SCIP_VARTYPE_IMPLINT    
+        SCIP_VARTYPE SCIP_VARTYPE_CONTINUOUS 
+
+    ctypedef int SCIP_OBJSENSE
+    cdef extern from "scip/type_prob.h":
+        SCIP_OBJSENSE SCIP_OBJSENSE_MAXIMIZE 
+        SCIP_OBJSENSE SCIP_OBJSENSE_MINIMIZE 
+
+    # This version is used in LPI.
+    ctypedef int SCIP_OBJSEN 
+    cdef extern from "lpi/type_lpi.h":
+        SCIP_OBJSEN SCIP_OBJSEN_MAXIMIZE 
+        SCIP_OBJSEN SCIP_OBJSEN_MINIMIZE 
+
+    ctypedef int SCIP_BOUNDTYPE 
+    cdef extern from "scip/type_lp.h":
+        SCIP_BOUNDTYPE SCIP_BOUNDTYPE_LOWER 
+        SCIP_BOUNDTYPE SCIP_BOUNDTYPE_UPPER 
+
+    ctypedef int SCIP_RESULT 
+    cdef extern from "scip/type_result.h":
+        SCIP_RESULT SCIP_DIDNOTRUN   
+        SCIP_RESULT SCIP_DELAYED     
+        SCIP_RESULT SCIP_DIDNOTFIND  
+        SCIP_RESULT SCIP_FEASIBLE    
+        SCIP_RESULT SCIP_INFEASIBLE  
+        SCIP_RESULT SCIP_UNBOUNDED   
+        SCIP_RESULT SCIP_CUTOFF      
+        SCIP_RESULT SCIP_SEPARATED   
+        SCIP_RESULT SCIP_NEWROUND    
+        SCIP_RESULT SCIP_REDUCEDDOM  
+        SCIP_RESULT SCIP_CONSADDED   
+        SCIP_RESULT SCIP_CONSCHANGED 
+        SCIP_RESULT SCIP_BRANCHED    
+        SCIP_RESULT SCIP_SOLVELP     
+        SCIP_RESULT SCIP_FOUNDSOL    
+        SCIP_RESULT SCIP_SUSPENDED   
+        SCIP_RESULT SCIP_SUCCESS     
+
+    ctypedef int SCIP_STATUS 
+    cdef extern from "scip/type_stat.h":
+        SCIP_STATUS SCIP_STATUS_UNKNOWN        
+        SCIP_STATUS SCIP_STATUS_USERINTERRUPT  
+        SCIP_STATUS SCIP_STATUS_NODELIMIT      
+        SCIP_STATUS SCIP_STATUS_TOTALNODELIMIT 
+        SCIP_STATUS SCIP_STATUS_STALLNODELIMIT 
+        SCIP_STATUS SCIP_STATUS_TIMELIMIT      
+        SCIP_STATUS SCIP_STATUS_MEMLIMIT       
+        SCIP_STATUS SCIP_STATUS_GAPLIMIT       
+        SCIP_STATUS SCIP_STATUS_SOLLIMIT       
+        SCIP_STATUS SCIP_STATUS_BESTSOLLIMIT   
+        SCIP_STATUS SCIP_STATUS_RESTARTLIMIT
+        SCIP_STATUS SCIP_STATUS_PRIMALLIMIT
+        SCIP_STATUS SCIP_STATUS_DUALLIMIT
+        SCIP_STATUS SCIP_STATUS_OPTIMAL        
+        SCIP_STATUS SCIP_STATUS_INFEASIBLE     
+        SCIP_STATUS SCIP_STATUS_UNBOUNDED      
+        SCIP_STATUS SCIP_STATUS_INFORUNBD      
+
+    ctypedef int SCIP_STAGE
+    cdef extern from "scip/type_set.h":
+        SCIP_STAGE SCIP_STAGE_INIT         
+        SCIP_STAGE SCIP_STAGE_PROBLEM      
+        SCIP_STAGE SCIP_STAGE_TRANSFORMING 
+        SCIP_STAGE SCIP_STAGE_TRANSFORMED 
+        SCIP_STAGE SCIP_STAGE_INITPRESOLVE 
+        SCIP_STAGE SCIP_STAGE_PRESOLVING   
+        SCIP_STAGE SCIP_STAGE_EXITPRESOLVE 
+        SCIP_STAGE SCIP_STAGE_PRESOLVED    
+        SCIP_STAGE SCIP_STAGE_INITSOLVE    
+        SCIP_STAGE SCIP_STAGE_SOLVING      
+        SCIP_STAGE SCIP_STAGE_SOLVED       
+        SCIP_STAGE SCIP_STAGE_EXITSOLVE    
+        SCIP_STAGE SCIP_STAGE_FREETRANS    
+        SCIP_STAGE SCIP_STAGE_FREE         
+
+    ctypedef int SCIP_NODETYPE
+    cdef extern from "scip/type_tree.h":
+        SCIP_NODETYPE SCIP_NODETYPE_FOCUSNODE   
+        SCIP_NODETYPE SCIP_NODETYPE_PROBINGNODE 
+        SCIP_NODETYPE SCIP_NODETYPE_SIBLING     
+        SCIP_NODETYPE SCIP_NODETYPE_CHILD       
+        SCIP_NODETYPE SCIP_NODETYPE_LEAF        
+        SCIP_NODETYPE SCIP_NODETYPE_DEADEND     
+        SCIP_NODETYPE SCIP_NODETYPE_JUNCTION    
+        SCIP_NODETYPE SCIP_NODETYPE_PSEUDOFORK  
+        SCIP_NODETYPE SCIP_NODETYPE_FORK        
+        SCIP_NODETYPE SCIP_NODETYPE_SUBROOT     
+        SCIP_NODETYPE SCIP_NODETYPE_REFOCUSNODE 
+
+    ctypedef int SCIP_PARAMSETTING
+    cdef extern from "scip/type_paramset.h":
+        SCIP_PARAMSETTING SCIP_PARAMSETTING_DEFAULT    
+        SCIP_PARAMSETTING SCIP_PARAMSETTING_AGGRESSIVE 
+        SCIP_PARAMSETTING SCIP_PARAMSETTING_FAST       
+        SCIP_PARAMSETTING SCIP_PARAMSETTING_OFF        
+
+    ctypedef int SCIP_PARAMTYPE
+    cdef extern from "scip/type_paramset.h":
+        SCIP_PARAMTYPE SCIP_PARAMTYPE_BOOL
+        SCIP_PARAMTYPE SCIP_PARAMTYPE_INT
+        SCIP_PARAMTYPE SCIP_PARAMTYPE_LONGINT
+        SCIP_PARAMTYPE SCIP_PARAMTYPE_REAL
+        SCIP_PARAMTYPE SCIP_PARAMTYPE_CHAR
+        SCIP_PARAMTYPE SCIP_PARAMTYPE_STRING
+
+    ctypedef int SCIP_PARAMEMPHASIS
+    cdef extern from "scip/type_paramset.h":
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_DEFAULT
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_CPSOLVER
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_EASYCIP
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_FEASIBILITY
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_HARDLP
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_OPTIMALITY
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_COUNTER
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_PHASEFEAS
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_PHASEIMPROVE
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_PHASEPROOF
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_NUMERICS
+        SCIP_PARAMEMPHASIS SCIP_PARAMEMPHASIS_BENCHMARK
+
+    ctypedef unsigned long SCIP_PROPTIMING 
+    cdef extern from "scip/type_timing.h":
+        SCIP_PROPTIMING SCIP_PROPTIMING_BEFORELP     
+        SCIP_PROPTIMING SCIP_PROPTIMING_DURINGLPLOOP 
+        SCIP_PROPTIMING SCIP_PROPTIMING_AFTERLPLOOP  
+        SCIP_PROPTIMING SCIP_PROPTIMING_AFTERLPNODE  
+
+    ctypedef unsigned long SCIP_PRESOLTIMING 
+    cdef extern from "scip/type_timing.h":
+        SCIP_PRESOLTIMING SCIP_PRESOLTIMING_NONE       
+        SCIP_PRESOLTIMING SCIP_PRESOLTIMING_FAST       
+        SCIP_PRESOLTIMING SCIP_PRESOLTIMING_MEDIUM     
+        SCIP_PRESOLTIMING SCIP_PRESOLTIMING_EXHAUSTIVE 
+
+    ctypedef unsigned long SCIP_HEURTIMING 
+    cdef extern from "scip/type_timing.h":
+        SCIP_HEURTIMING SCIP_HEURTIMING_BEFORENODE        
+        SCIP_HEURTIMING SCIP_HEURTIMING_DURINGLPLOOP      
+        SCIP_HEURTIMING SCIP_HEURTIMING_AFTERLPLOOP       
+        SCIP_HEURTIMING SCIP_HEURTIMING_AFTERLPNODE       
+        SCIP_HEURTIMING SCIP_HEURTIMING_AFTERPSEUDONODE   
+        SCIP_HEURTIMING SCIP_HEURTIMING_AFTERLPPLUNGE     
+        SCIP_HEURTIMING SCIP_HEURTIMING_AFTERPSEUDOPLUNGE 
+        SCIP_HEURTIMING SCIP_HEURTIMING_DURINGPRICINGLOOP 
+        SCIP_HEURTIMING SCIP_HEURTIMING_BEFOREPRESOL      
+        SCIP_HEURTIMING SCIP_HEURTIMING_DURINGPRESOLLOOP  
+        SCIP_HEURTIMING SCIP_HEURTIMING_AFTERPROPLOOP     
+
+    ctypedef int SCIP_EXPR
+    cdef extern from "scip/type_expr.h":
+        SCIP_EXPR SCIP_EXPR_VARIDX
+        SCIP_EXPR SCIP_EXPR_CONST
+        SCIP_EXPR SCIP_EXPR_PARAM
+        SCIP_EXPR SCIP_EXPR_PLUS
+        SCIP_EXPR SCIP_EXPR_MINUS
+        SCIP_EXPR SCIP_EXPR_MUL
+        SCIP_EXPR SCIP_EXPR_DIV
+        SCIP_EXPR SCIP_EXPR_SQUARE
+        SCIP_EXPR SCIP_EXPR_SQRT
+        SCIP_EXPR SCIP_EXPR_REALPOWER
+        SCIP_EXPR SCIP_EXPR_INTPOWER
+        SCIP_EXPR SCIP_EXPR_SIGNPOWER
+        SCIP_EXPR SCIP_EXPR_EXP
+        SCIP_EXPR SCIP_EXPR_LOG
+        SCIP_EXPR SCIP_EXPR_SIN
+        SCIP_EXPR SCIP_EXPR_COS
+        SCIP_EXPR SCIP_EXPR_TAN
+        SCIP_EXPR SCIP_EXPR_MIN
+        SCIP_EXPR SCIP_EXPR_MAX
+        SCIP_EXPR SCIP_EXPR_ABS
+        SCIP_EXPR SCIP_EXPR_SIGN
+        SCIP_EXPR SCIP_EXPR_SUM
+        SCIP_EXPR SCIP_EXPR_PRODUCT
+        SCIP_EXPR SCIP_EXPR_LINEAR
+        SCIP_EXPR SCIP_EXPR_QUADRATIC
+        SCIP_EXPR SCIP_EXPR_POLYNOMIAL
+        SCIP_EXPR SCIP_EXPR_USER
+        SCIP_EXPR SCIP_EXPR_LAST
+
+    ctypedef int SCIP_BASESTAT 
+    cdef extern from "lpi/type_lpi.h":
+        SCIP_BASESTAT SCIP_BASESTAT_LOWER 
+        SCIP_BASESTAT SCIP_BASESTAT_BASIC 
+        SCIP_BASESTAT SCIP_BASESTAT_UPPER 
+        SCIP_BASESTAT SCIP_BASESTAT_ZERO  
+
+    ctypedef unsigned long SCIP_EVENTTYPE 
+    cdef extern from "scip/type_event.h":
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_DISABLED          
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_VARADDED          
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_VARDELETED       
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_VARFIXED          
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_VARUNLOCKED      
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_OBJCHANGED             
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_GLBCHANGED        
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_GUBCHANGED       
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_LBTIGHTENED      
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_LBRELAXED        
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_UBTIGHTENED      
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_UBRELAXED        
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_GHOLEADDED       
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_GHOLEREMOVED     
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_LHOLEADDED       
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_LHOLEREMOVED     
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_IMPLADDED        
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_PRESOLVEROUND    
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_NODEFOCUSED      
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_NODEFEASIBLE     
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_NODEINFEASIBLE   
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_NODEBRANCHED     
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_NODEDELETE       
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_FIRSTLPSOLVED    
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_LPSOLVED         
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_POORSOLFOUND     
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_BESTSOLFOUND     
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWADDEDSEPA     
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWDELETEDSEPA   
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWADDEDLP       
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWDELETEDLP     
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWCOEFCHANGED   
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWCONSTCHANGED  
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWSIDECHANGED   
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_SYNC             
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_GBDCHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_LBCHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_UBCHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_BOUNDTIGHTENED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_BOUNDRELAXED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_BOUNDCHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_GHOLECHANGED        
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_LHOLECHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_HOLECHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_DOMCHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_VARCHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_VAREVENT
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_NODESOLVED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_NODEEVENT
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_LPEVENT
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_SOLFOUND
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_SOLEVENT
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWCHANGED
+        SCIP_EVENTTYPE SCIP_EVENTTYPE_ROWEVENT
+
+
+    ctypedef int SCIP_LPSOLQUALITY 
+    cdef extern from "lpi/type_lpi.h":
+        SCIP_LPSOLQUALITY SCIP_LPSOLQUALITY_ESTIMCONDITION 
+        SCIP_LPSOLQUALITY SCIP_LPSOLQUALITY_EXACTCONDITION 
+
+    ctypedef int SCIP_LOCKTYPE 
+    cdef extern from "scip/type_var.h":
+        SCIP_LOCKTYPE SCIP_LOCKTYPE_MODEL    
+        SCIP_LOCKTYPE SCIP_LOCKTYPE_CONFLICT 
+
+    ctypedef int SCIP_BENDERSENFOTYPE 
+    cdef extern from "scip/type_benders.h":
+        SCIP_BENDERSENFOTYPE SCIP_BENDERSENFOTYPE_LP      
+        SCIP_BENDERSENFOTYPE SCIP_BENDERSENFOTYPE_RELAX   
+        SCIP_BENDERSENFOTYPE SCIP_BENDERSENFOTYPE_PSEUDO  
+        SCIP_BENDERSENFOTYPE SCIP_BENDERSENFOTYPE_CHECK   
+
+    ctypedef int SCIP_LPSOLSTAT 
+    cdef extern from "scip/type_lp.h":
+        SCIP_LPSOLSTAT SCIP_LPSOLSTAT_NOTSOLVED    
+        SCIP_LPSOLSTAT SCIP_LPSOLSTAT_OPTIMAL      
+        SCIP_LPSOLSTAT SCIP_LPSOLSTAT_INFEASIBLE   
+        SCIP_LPSOLSTAT SCIP_LPSOLSTAT_UNBOUNDEDRAY 
+        SCIP_LPSOLSTAT SCIP_LPSOLSTAT_OBJLIMIT     
+        SCIP_LPSOLSTAT SCIP_LPSOLSTAT_ITERLIMIT    
+        SCIP_LPSOLSTAT SCIP_LPSOLSTAT_TIMELIMIT    
+        SCIP_LPSOLSTAT SCIP_LPSOLSTAT_ERROR        
+
+    ctypedef int SCIP_BRANCHDIR 
+    cdef extern from "scip/type_history.h":
+        SCIP_BRANCHDIR SCIP_BRANCHDIR_DOWNWARDS 
+        SCIP_BRANCHDIR SCIP_BRANCHDIR_UPWARDS   
+        SCIP_BRANCHDIR SCIP_BRANCHDIR_FIXED     
+        SCIP_BRANCHDIR SCIP_BRANCHDIR_AUTO      
+
+    ctypedef int SCIP_BOUNDCHGTYPE 
+    cdef extern from "scip/type_var.h":
+        SCIP_BOUNDCHGTYPE SCIP_BOUNDCHGTYPE_BRANCHING 
+        SCIP_BOUNDCHGTYPE SCIP_BOUNDCHGTYPE_CONSINFER 
+        SCIP_BOUNDCHGTYPE SCIP_BOUNDCHGTYPE_PROPINFER 
+
+    ctypedef int SCIP_ROWORIGINTYPE 
+    cdef extern from "scip/type_lp.h":
+        SCIP_ROWORIGINTYPE SCIP_ROWORIGINTYPE_UNSPEC 
+        SCIP_ROWORIGINTYPE SCIP_ROWORIGINTYPE_CONS   
+        SCIP_ROWORIGINTYPE SCIP_ROWORIGINTYPE_SEPA   
+        SCIP_ROWORIGINTYPE SCIP_ROWORIGINTYPE_REOPT  
+
+    ctypedef bint SCIP_Bool
+
+    ctypedef long long SCIP_Longint
+
+    ctypedef double SCIP_Real
+
+    ctypedef struct SCIP:
+        pass
+
+    ctypedef struct SCIP_VAR:
+        pass
+
+    ctypedef struct SCIP_CONS:
+        pass
+
+    ctypedef struct SCIP_ROW:
+        pass
+
+    ctypedef struct SCIP_NLROW:
+        pass
+
+    ctypedef struct SCIP_COL:
+        pass
+
+    ctypedef struct SCIP_SOL:
+        pass
+
+    ctypedef struct FILE:
+        pass
+
+    ctypedef struct SYM_GRAPH:
+        pass
+
+    ctypedef struct SCIP_READER:
+        pass
+
+    ctypedef struct SCIP_READERDATA:
+        pass
+
+    ctypedef struct SCIP_PROBDATA:
+        pass
+
+    ctypedef struct SCIP_PRICER:
+        pass
+
+    ctypedef struct SCIP_PRICERDATA:
+        pass
+
+    ctypedef struct SCIP_PROP:
+        pass
+
+    ctypedef struct SCIP_PROPDATA:
+        pass
+
+    ctypedef struct SCIP_PROPTIMING:
+        pass
+
+    ctypedef struct SCIP_PRESOLTIMING:
+        pass
+
+    ctypedef struct SCIP_PRESOL:
+        pass
+
+    ctypedef struct SCIP_PRESOLDATA:
+        pass
+
+    ctypedef struct SCIP_HEUR:
+        pass
+
+    ctypedef struct SCIP_HEURDATA:
+        pass
+
+    ctypedef struct SCIP_RELAX:
+        pass
+
+    ctypedef struct SCIP_RELAXDATA:
+        pass
+
+    ctypedef struct SCIP_NODE:
+        pass
+
+    ctypedef struct SCIP_NODESEL:
+        pass
+
+    ctypedef struct SCIP_NODESELDATA:
+        pass
+
+    ctypedef struct SCIP_BRANCHRULE:
+        pass
+
+    ctypedef struct SCIP_BRANCHRULEDATA:
+        pass
+
+    ctypedef struct SCIP_CUTSEL:
+        pass
+
+    ctypedef struct SCIP_CUTSELDATA:
+        pass
+
+    ctypedef struct SCIP_PRESOL:
+        pass
+
+    ctypedef struct SCIP_HEURTIMING:
+        pass
+
+    ctypedef struct SCIP_SEPA:
+        pass
+
+    ctypedef struct SCIP_SEPADATA:
+        pass
+
+    ctypedef struct SCIP_CONSHDLR:
+        pass
+
+    ctypedef struct SCIP_CONSHDLRDATA:
+        pass
+
+    ctypedef struct SCIP_CONSDATA:
+        pass
+
+    ctypedef struct SCIP_VARDATA:
+        pass
+
+    ctypedef struct SCIP_EVENT:
+        pass
+
+    ctypedef struct SCIP_EVENTDATA:
+        pass
+
+    ctypedef struct SCIP_EVENTHDLR:
+        pass
+
+    ctypedef struct SCIP_EVENTHDLRDATA:
+        pass
+
+    ctypedef struct SCIP_DIVESET:
+        pass
+
+    ctypedef struct SCIP_HASHMAP:
+        pass
+
+    ctypedef struct SCIP_BDCHGIDX:
+        pass
+
+    ctypedef struct SCIP_MESSAGEHDLR:
+        pass
+
+    ctypedef struct SCIP_MESSAGEHDLRDATA:
+        pass
+
+    ctypedef struct SCIP_LPI:
+        pass
+
+    ctypedef struct BMS_BLKMEM:
+        pass
+
+    ctypedef struct SCIP_EXPR:
+        pass
+
+    ctypedef struct SCIP_EXPRHDLR:
+        pass
+
+    ctypedef struct SCIP_EXPRDATA:
+        pass
+
+    ctypedef struct SCIP_DECL_EXPR_OWNERCREATE:
+        pass
+
+    ctypedef struct SCIP_BENDERS:
+        pass
+
+    ctypedef struct SCIP_BENDERSDATA:
+        pass
+
+    ctypedef struct SCIP_BENDERSCUT:
+        pass
+
+    ctypedef struct SCIP_BENDERSCUTDATA:
+        pass
+
+    ctypedef struct SCIP_BOUNDCHG:
+        pass
+
+    ctypedef union SCIP_DOMCHG:
+        pass
+
+    ctypedef void (*messagecallback) (SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *msg) noexcept
+    ctypedef void (*errormessagecallback) (void *data, FILE *file, const char *msg)
+    ctypedef SCIP_RETCODE (*messagehdlrfree) (SCIP_MESSAGEHDLR *messagehdlr)
+
+    # General SCIP Methods
+    SCIP_RETCODE SCIPcreate(SCIP** scip)
+    SCIP_RETCODE SCIPfree(SCIP** scip)
+    SCIP_RETCODE SCIPcopy(SCIP*                 sourcescip,
+                          SCIP*                 targetscip,
+                          SCIP_HASHMAP*         varmap,
+                          SCIP_HASHMAP*         consmap,
+                          const char*           suffix,
+                          SCIP_Bool             globalcopy,
+                          SCIP_Bool             enablepricing,
+                          SCIP_Bool             threadsafe,
+                          SCIP_Bool             passmessagehdlr,
+                          SCIP_Bool*            valid)
+    SCIP_RETCODE SCIPcopyOrig(SCIP*                 sourcescip,
+                              SCIP*                 targetscip,
+                              SCIP_HASHMAP*         varmap,
+                              SCIP_HASHMAP*         consmap,
+                              const char*           suffix,
+                              SCIP_Bool             enablepricing,
+                              SCIP_Bool             threadsafe,
+                              SCIP_Bool             passmessagehdlr,
+                              SCIP_Bool*            valid)
+    SCIP_RETCODE SCIPmessagehdlrCreate(SCIP_MESSAGEHDLR **messagehdlr,
+                                       SCIP_Bool bufferedoutput,
+                                       const char *filename,
+                                       SCIP_Bool quiet,
+                                       messagecallback,
+                                       messagecallback,
+                                       messagecallback,
+                                       messagehdlrfree,
+                                       SCIP_MESSAGEHDLRDATA *messagehdlrdata)
+
+    SCIP_RETCODE SCIPsetMessagehdlr(SCIP* scip, SCIP_MESSAGEHDLR* messagehdlr)
+    void SCIPsetMessagehdlrQuiet(SCIP* scip, SCIP_Bool quiet)
+    void SCIPmessageSetErrorPrinting(errormessagecallback, void* data)
+    void SCIPsetMessagehdlrLogfile(SCIP* scip, const char* filename)
+    SCIP_Real SCIPversion()
+    void SCIPprintVersion(SCIP* scip, FILE* outfile)
+    void SCIPprintExternalCodes(SCIP* scip, FILE* outfile)
+    SCIP_Real SCIPgetTotalTime(SCIP* scip)
+    SCIP_Real SCIPgetSolvingTime(SCIP* scip)
+    SCIP_Real SCIPgetReadingTime(SCIP* scip)
+    SCIP_Real SCIPgetPresolvingTime(SCIP* scip)
+    SCIP_STAGE SCIPgetStage(SCIP* scip)
+    SCIP_RETCODE SCIPsetProbName(SCIP* scip, char* name)
+    const char* SCIPgetProbName(SCIP* scip)
+
+    # Diving methods
+    SCIP_RETCODE SCIPstartDive(SCIP* scip)
+    SCIP_RETCODE SCIPchgVarObjDive(SCIP* scip, SCIP_VAR* var, SCIP_Real newobj)
+    SCIP_RETCODE SCIPchgVarLbDive(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPchgVarUbDive(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_Real SCIPgetVarLbDive(SCIP* scip, SCIP_VAR* var)
+    SCIP_Real SCIPgetVarUbDive(SCIP* scip, SCIP_VAR* var)
+    SCIP_RETCODE SCIPsolveDiveLP(SCIP* scip, int itlim, SCIP_Bool* lperror, SCIP_Bool* cutoff)
+    SCIP_RETCODE SCIPchgRowLhsDive(SCIP* scip, SCIP_ROW* row, SCIP_Real newlhs)
+    SCIP_RETCODE SCIPchgRowRhsDive(SCIP* scip, SCIP_ROW* row, SCIP_Real newrhs)
+    SCIP_RETCODE SCIPaddRowDive(SCIP* scip, SCIP_ROW* row)
+    SCIP_RETCODE SCIPendDive(SCIP* scip)
+
+    # Probing methods
+    SCIP_RETCODE SCIPstartProbing(SCIP* scip)
+    SCIP_RETCODE SCIPnewProbingNode(SCIP* scip)
+    SCIP_RETCODE SCIPgetProbingDepth(SCIP* scip)
+    SCIP_RETCODE SCIPbacktrackProbing(SCIP* scip, int probingdepth)
+    SCIP_RETCODE SCIPchgVarObjProbing(SCIP* scip, SCIP_VAR* var, SCIP_Real newobj)
+    SCIP_RETCODE SCIPchgVarUbProbing(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPchgVarLbProbing(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPsolveProbingLP(SCIP* scip, int itlim, SCIP_Bool* lperror, SCIP_Bool* cutoff)
+    SCIP_RETCODE SCIPendProbing(SCIP* scip)
+    SCIP_RETCODE SCIPfixVarProbing(SCIP* scip, SCIP_VAR* var, SCIP_Real fixedval)
+    SCIP_Bool SCIPisObjChangedProbing(SCIP* scip)
+    SCIP_Bool SCIPinProbing(SCIP* scip)
+    SCIP_RETCODE SCIPapplyCutsProbing(SCIP* scip, SCIP_Bool* cutoff)
+    SCIP_RETCODE SCIPpropagateProbing(SCIP* scip, int maxproprounds, SCIP_Bool* cutoff, SCIP_Longint* ndomredsfound)
+
+
+    # Event Methods
+    SCIP_RETCODE SCIPcatchEvent(SCIP* scip,
+                                SCIP_EVENTTYPE eventtype,
+                                SCIP_EVENTHDLR* eventhdlr,
+                                SCIP_EVENTDATA* eventdata,
+                                int* filterpos)
+    SCIP_RETCODE SCIPdropEvent(SCIP* scip,
+                               SCIP_EVENTTYPE eventtype,
+                               SCIP_EVENTHDLR* eventhdlr,
+                               SCIP_EVENTDATA* eventdata,
+                               int filterpos)
+    SCIP_RETCODE SCIPcatchVarEvent(SCIP* scip,
+                                   SCIP_VAR* var,
+                                   SCIP_EVENTTYPE eventtype,
+                                   SCIP_EVENTHDLR* eventhdlr,
+                                   SCIP_EVENTDATA* eventdata,
+                                   int* filterpos)
+    SCIP_RETCODE SCIPdropVarEvent(SCIP* scip,
+                                  SCIP_VAR* var,
+                                  SCIP_EVENTTYPE eventtype,
+                                  SCIP_EVENTHDLR* eventhdlr,
+                                  SCIP_EVENTDATA* eventdata,
+                                  int filterpos)
+    SCIP_RETCODE SCIPcatchRowEvent(SCIP* scip,
+                                   SCIP_ROW* row,
+                                   SCIP_EVENTTYPE eventtype,
+                                   SCIP_EVENTHDLR* eventhdlr,
+                                   SCIP_EVENTDATA* eventdata,
+                                   int* filterpos)
+    SCIP_RETCODE SCIPdropRowEvent(SCIP* scip,
+                                  SCIP_ROW* row,
+                                  SCIP_EVENTTYPE eventtype,
+                                  SCIP_EVENTHDLR* eventhdlr,
+                                  SCIP_EVENTDATA* eventdata,
+                                  int filterpos)
+    SCIP_EVENTHDLR* SCIPfindEventhdlr(SCIP* scip, const char* name)
+    SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT* event)
+    SCIP_Real SCIPeventGetNewbound(SCIP_EVENT* event)
+    SCIP_Real SCIPeventGetOldbound(SCIP_EVENT* event)
+    SCIP_VAR* SCIPeventGetVar(SCIP_EVENT* event)
+    SCIP_NODE* SCIPeventGetNode(SCIP_EVENT* event)
+    SCIP_ROW* SCIPeventGetRow(SCIP_EVENT* event)
+    SCIP_RETCODE SCIPinterruptSolve(SCIP* scip)
+    SCIP_RETCODE SCIPrestartSolve(SCIP* scip)
+
+
+    # Global Problem Methods
+    SCIP_RETCODE SCIPcreateProbBasic(SCIP* scip, char* name)
+    SCIP_RETCODE SCIPfreeProb(SCIP* scip)
+    SCIP_RETCODE SCIPaddVar(SCIP* scip, SCIP_VAR* var)
+    SCIP_RETCODE SCIPdelVar(SCIP* scip, SCIP_VAR* var, SCIP_Bool* deleted)
+    SCIP_RETCODE SCIPaddCons(SCIP* scip, SCIP_CONS* cons)
+    SCIP_RETCODE SCIPdelCons(SCIP* scip, SCIP_CONS* cons)
+    SCIP_CONS**  SCIPgetOrigConss(SCIP* scip)
+    int          SCIPgetNOrigConss(SCIP* scip)
+    SCIP_CONS*   SCIPfindOrigCons(SCIP* scip, const char*)
+    SCIP_CONS*   SCIPfindCons(SCIP* scip, const char*)
+    SCIP_RETCODE SCIPsetObjsense(SCIP* scip, SCIP_OBJSENSE objsense)
+    SCIP_OBJSENSE SCIPgetObjsense(SCIP* scip)
+    SCIP_RETCODE SCIPsetObjlimit(SCIP* scip, SCIP_Real objlimit)
+    SCIP_Real SCIPgetObjlimit(SCIP* scip)
+    SCIP_Real SCIPgetObjNorm(SCIP* scip)
+    SCIP_RETCODE SCIPaddObjoffset(SCIP* scip, SCIP_Real addval)
+    SCIP_RETCODE SCIPaddOrigObjoffset(SCIP* scip, SCIP_Real addval)
+    SCIP_Real SCIPgetOrigObjoffset(SCIP* scip)
+    SCIP_Real SCIPgetTransObjoffset(SCIP* scip)
+    SCIP_RETCODE SCIPsetPresolving(SCIP* scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
+    SCIP_RETCODE SCIPsetSeparating(SCIP* scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
+    SCIP_RETCODE SCIPsetHeuristics(SCIP* scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
+    SCIP_RETCODE SCIPsetRelaxation(SCIP* scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
+    SCIP_RETCODE SCIPwriteOrigProblem(SCIP* scip, char* filename, char* extension, SCIP_Bool genericnames)
+    SCIP_RETCODE SCIPwriteTransProblem(SCIP* scip, char* filename, char* extension, SCIP_Bool genericnames)
+    SCIP_RETCODE SCIPwriteLP(SCIP* scip, const char*)
+    SCIP_STATUS SCIPgetStatus(SCIP* scip)
+    SCIP_Real SCIPepsilon(SCIP* scip)
+    SCIP_Real SCIPfeastol(SCIP* scip)
+    SCIP_RETCODE SCIPsetObjIntegral(SCIP* scip)
+    SCIP_Real SCIPgetLocalOrigEstimate(SCIP* scip)
+    SCIP_Real SCIPgetLocalTransEstimate(SCIP* scip)
+
+    # Solve Methods
+    SCIP_RETCODE SCIPsolve(SCIP* scip)
+    SCIP_RETCODE SCIPsolveConcurrent(SCIP* scip)
+    SCIP_RETCODE SCIPfreeTransform(SCIP* scip)
+    SCIP_RETCODE SCIPpresolve(SCIP* scip)
+
+    # Node Methods
+    SCIP_NODE* SCIPgetCurrentNode(SCIP* scip)
+    SCIP_NODE* SCIPnodeGetParent(SCIP_NODE* node)
+    SCIP_Longint SCIPnodeGetNumber(SCIP_NODE* node)
+    int SCIPnodeGetDepth(SCIP_NODE* node)
+    SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE* node)
+    SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP* scip, SCIP_NODE* node, SCIP_Real newbound)
+    SCIP_Real SCIPnodeGetEstimate(SCIP_NODE* node)
+    SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE* node)
+    SCIP_Bool SCIPnodeIsActive(SCIP_NODE* node)
+    SCIP_Bool SCIPnodeIsPropagatedAgain(SCIP_NODE* node)
+    SCIP_Real SCIPcalcNodeselPriority(SCIP*	scip, SCIP_VAR* var, SCIP_BRANCHDIR	branchdir, SCIP_Real targetvalue)
+    SCIP_Real SCIPcalcChildEstimate(SCIP* scip, SCIP_VAR* var, SCIP_Real targetvalue)
+    SCIP_RETCODE SCIPcreateChild(SCIP* scip, SCIP_NODE** node, SCIP_Real nodeselprio, SCIP_Real estimate)
+    SCIP_Bool SCIPinRepropagation(SCIP* scip)
+    SCIP_RETCODE SCIPaddConsNode(SCIP* scip, SCIP_NODE* node, SCIP_CONS* cons, SCIP_NODE* validnode)
+    SCIP_RETCODE SCIPaddConsLocal(SCIP* scip, SCIP_CONS* cons, SCIP_NODE* validnode)
+    void SCIPnodeGetParentBranchings(SCIP_NODE* node,
+                                     SCIP_VAR** branchvars,
+                                     SCIP_Real* branchbounds,
+                                     SCIP_BOUNDTYPE* boundtypes,
+                                     int* nbranchvars,
+                                     int branchvarssize)
+    void SCIPnodeGetAddedConss(SCIP_NODE* node, SCIP_CONS** addedconss,
+                               int* naddedconss, int addedconsssize)
+    void SCIPnodeGetNDomchg(SCIP_NODE* node, int* nbranchings, int* nconsprop,
+                            int* nprop)
+    SCIP_DOMCHG* SCIPnodeGetDomchg(SCIP_NODE* node)
+
+    # Domain change methods
+    int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG* domchg)
+    SCIP_BOUNDCHG* SCIPdomchgGetBoundchg(SCIP_DOMCHG* domchg, int pos)
+
+    # Bound change methods
+    SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG* boundchg)
+    SCIP_VAR* SCIPboundchgGetVar(SCIP_BOUNDCHG* boundchg)
+    SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG* boundchg)
+    SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG* boundchg)
+    SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG* boundchg)
+
+    # Variable Methods
+    SCIP_RETCODE SCIPcreateVarBasic(SCIP* scip,
+                                    SCIP_VAR** var,
+                                    char* name,
+                                    SCIP_Real lb,
+                                    SCIP_Real ub,
+                                    SCIP_Real obj,
+                                    SCIP_VARTYPE vartype)
+    SCIP_RETCODE SCIPchgVarObj(SCIP* scip, SCIP_VAR* var, SCIP_Real newobj)
+    SCIP_RETCODE SCIPchgVarLb(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPchgVarUb(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPchgVarLbGlobal(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPchgVarUbGlobal(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPchgVarLbNode(SCIP* scip, SCIP_NODE* node, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPchgVarUbNode(SCIP* scip, SCIP_NODE* node, SCIP_VAR* var, SCIP_Real newbound)
+    SCIP_RETCODE SCIPtightenVarLb(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound,
+                                  SCIP_Bool force, SCIP_Bool* infeasible, SCIP_Bool* tightened)
+    SCIP_RETCODE SCIPtightenVarUb(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound,
+                                  SCIP_Bool force, SCIP_Bool* infeasible, SCIP_Bool* tightened)
+    SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound,
+                                        SCIP_Bool force, SCIP_Bool* infeasible, SCIP_Bool* tightened)
+    SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP* scip, SCIP_VAR* var, SCIP_Real newbound,
+                                        SCIP_Bool force, SCIP_Bool* infeasible, SCIP_Bool* tightened)
+    SCIP_RETCODE SCIPfixVar(SCIP* scip, SCIP_VAR* var, SCIP_Real fixedval, SCIP_Bool* infeasible, SCIP_Bool* fixed)
+    SCIP_RETCODE SCIPdelVar(SCIP* scip, SCIP_VAR* var, SCIP_Bool* deleted)
+
+    SCIP_RETCODE SCIPchgVarType(SCIP* scip, SCIP_VAR* var, SCIP_VARTYPE vartype, SCIP_Bool* infeasible)
+    SCIP_RETCODE SCIPcaptureVar(SCIP* scip, SCIP_VAR* var)
+    SCIP_RETCODE SCIPaddPricedVar(SCIP* scip, SCIP_VAR* var, SCIP_Real score)
+    SCIP_RETCODE SCIPreleaseVar(SCIP* scip, SCIP_VAR** var)
+    SCIP_RETCODE SCIPtransformVar(SCIP* scip, SCIP_VAR* var, SCIP_VAR** transvar)
+    SCIP_RETCODE SCIPgetTransformedVar(SCIP* scip, SCIP_VAR* var, SCIP_VAR** transvar)
+    SCIP_RETCODE SCIPaddVarLocks(SCIP* scip, SCIP_VAR* var, int nlocksdown, int nlocksup)
+    SCIP_VAR** SCIPgetVars(SCIP* scip)
+    SCIP_VAR** SCIPgetOrigVars(SCIP* scip)
+    const char* SCIPvarGetName(SCIP_VAR* var)
+    int SCIPvarGetIndex(SCIP_VAR* var)
+    int SCIPgetNVars(SCIP* scip)
+    int SCIPgetNOrigVars(SCIP* scip)
+    int SCIPgetNIntVars(SCIP* scip)
+    int SCIPgetNBinVars(SCIP* scip)
+    SCIP_VARTYPE SCIPvarGetType(SCIP_VAR* var)
+    SCIP_Bool SCIPvarIsOriginal(SCIP_VAR* var)
+    SCIP_Bool SCIPvarIsTransformed(SCIP_VAR* var)
+    SCIP_COL* SCIPvarGetCol(SCIP_VAR* var)
+    SCIP_Bool SCIPvarIsInLP(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetLbLocal(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetUbLocal(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetObj(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetLPSol(SCIP_VAR* var)
+    void SCIPvarSetData(SCIP_VAR* var, SCIP_VARDATA* vardata)
+    SCIP_VARDATA* SCIPvarGetData(SCIP_VAR* var)
+    SCIP_Real SCIPvarGetAvgSol(SCIP_VAR* var)
+    SCIP_Real SCIPgetVarPseudocost(SCIP* scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
+    SCIP_Real SCIPvarGetCutoffSum(SCIP_VAR* var, SCIP_BRANCHDIR dir)
+    SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR* var, SCIP_BRANCHDIR dir)
+
+    # LP Methods
+    SCIP_RETCODE SCIPgetLPColsData(SCIP* scip, SCIP_COL*** cols, int* ncols)
+    SCIP_RETCODE SCIPgetLPRowsData(SCIP* scip, SCIP_ROW*** rows, int* nrows)
+    SCIP_RETCODE SCIPgetLPBasisInd(SCIP* scip, int* basisind)
+    SCIP_RETCODE SCIPgetLPBInvRow(SCIP* scip, int r, SCIP_Real* coefs, int* inds, int* ninds)
+    SCIP_RETCODE SCIPgetLPBInvARow(SCIP* scip, int r, SCIP_Real* binvrow, SCIP_Real* coefs, int* inds, int* ninds)
+    SCIP_RETCODE SCIPconstructLP(SCIP* scip, SCIP_Bool* cutoff)
+    SCIP_Real SCIPgetLPObjval(SCIP* scip)
+    SCIP_Bool SCIPisLPSolBasic(SCIP* scip)
+    SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP* scip)
+    int SCIPgetNLPRows(SCIP* scip)
+    int SCIPgetNLPCols(SCIP* scip)
+    SCIP_COL** SCIPgetLPCols(SCIP *scip)
+    SCIP_ROW** SCIPgetLPRows(SCIP *scip)
+
+    # Cutting Plane Methods
+    SCIP_RETCODE SCIPaddPoolCut(SCIP* scip, SCIP_ROW* row)
+    SCIP_Real SCIPgetCutEfficacy(SCIP* scip, SCIP_SOL* sol, SCIP_ROW* cut)
+    SCIP_Bool SCIPisCutEfficacious(SCIP* scip, SCIP_SOL* sol, SCIP_ROW* cut)
+    SCIP_Real SCIPgetCutLPSolCutoffDistance(SCIP* scip, SCIP_SOL* sol, SCIP_ROW* cut)
+    int SCIPgetNCuts(SCIP* scip)
+    int SCIPgetNCutsApplied(SCIP* scip)
+    SCIP_RETCODE SCIPseparateSol(SCIP* scip, SCIP_SOL* sol, SCIP_Bool pretendroot, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool* delayed, SCIP_Bool* cutoff)
+
+    # Constraint Methods
+    SCIP_RETCODE SCIPcaptureCons(SCIP* scip, SCIP_CONS* cons)
+    SCIP_RETCODE SCIPreleaseCons(SCIP* scip, SCIP_CONS** cons)
+    SCIP_RETCODE SCIPtransformCons(SCIP* scip, SCIP_CONS* cons, SCIP_CONS** transcons)
+    SCIP_RETCODE SCIPgetTransformedCons(SCIP* scip, SCIP_CONS* cons, SCIP_CONS** transcons)
+    SCIP_RETCODE SCIPgetConsVars(SCIP* scip, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success)
+    SCIP_RETCODE SCIPgetConsNVars(SCIP* scip, SCIP_CONS* cons, int* nvars, SCIP_Bool* success)
+    SCIP_CONS** SCIPgetConss(SCIP* scip)
+    const char* SCIPconsGetName(SCIP_CONS* cons)
+    int SCIPgetNConss(SCIP* scip)
+    SCIP_Bool SCIPconsIsOriginal(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsTransformed(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsInitial(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsSeparated(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsEnforced(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsChecked(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsPropagated(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsLocal(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsModifiable(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsDynamic(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsRemovable(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS* cons)
+    SCIP_Bool SCIPconsIsActive(SCIP_CONS* cons)
+    SCIP_CONSDATA* SCIPconsGetData(SCIP_CONS* cons)
+    SCIP_CONSHDLR* SCIPconsGetHdlr(SCIP_CONS* cons)
+    const char* SCIPconshdlrGetName(SCIP_CONSHDLR* conshdlr)
+    SCIP_RETCODE SCIPdelConsLocal(SCIP* scip, SCIP_CONS* cons)
+    SCIP_RETCODE SCIPdelCons(SCIP* scip, SCIP_CONS* cons)
+    SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
+    SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
+    SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
+    SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
+
+    # Primal Solution Methods
+    SCIP_SOL** SCIPgetSols(SCIP* scip)
+    int SCIPgetNSols(SCIP* scip)
+    int SCIPgetNSolsFound(SCIP* scip)
+    int SCIPgetNLimSolsFound(SCIP* scip)
+    int SCIPgetNBestSolsFound(SCIP* scip)
+    SCIP_SOL* SCIPgetBestSol(SCIP* scip)
+    SCIP_Real SCIPgetSolVal(SCIP* scip, SCIP_SOL* sol, SCIP_VAR* var)
+    SCIP_RETCODE SCIPwriteVarName(SCIP* scip, FILE* outfile, SCIP_VAR* var, SCIP_Bool vartype)
+    SCIP_Real SCIPgetSolOrigObj(SCIP* scip, SCIP_SOL* sol)
+    SCIP_Real SCIPgetSolTransObj(SCIP* scip, SCIP_SOL* sol)
+    SCIP_RETCODE SCIPcreateSol(SCIP* scip, SCIP_SOL** sol, SCIP_HEUR* heur)
+    SCIP_RETCODE SCIPcreatePartialSol(SCIP* scip, SCIP_SOL** sol,SCIP_HEUR* heur)
+    SCIP_RETCODE SCIPcreateOrigSol(SCIP* scip, SCIP_SOL** sol, SCIP_HEUR* heur)    
+    SCIP_RETCODE SCIPsetSolVal(SCIP* scip, SCIP_SOL* sol, SCIP_VAR* var, SCIP_Real val)
+    SCIP_RETCODE SCIPtrySolFree(SCIP* scip, SCIP_SOL** sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool* stored)
+    SCIP_RETCODE SCIPtrySol(SCIP* scip, SCIP_SOL* sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool* stored)
+    SCIP_RETCODE SCIPfreeSol(SCIP* scip, SCIP_SOL** sol)
+    SCIP_RETCODE SCIPprintBestSol(SCIP* scip, FILE* outfile, SCIP_Bool printzeros)
+    SCIP_RETCODE SCIPprintBestTransSol(SCIP* scip, FILE* outfile, SCIP_Bool printzeros)
+    SCIP_RETCODE SCIPprintSol(SCIP* scip, SCIP_SOL* sol, FILE* outfile, SCIP_Bool printzeros)
+    SCIP_RETCODE SCIPprintTransSol(SCIP* scip, SCIP_SOL* sol, FILE* outfile, SCIP_Bool printzeros)
+    SCIP_Real SCIPgetPrimalbound(SCIP* scip)
+    SCIP_Real SCIPgetGap(SCIP* scip)
+    int SCIPgetDepth(SCIP* scip)
+    SCIP_Bool SCIPhasPrimalRay(SCIP * scip)
+    SCIP_Real SCIPgetPrimalRayVal(SCIP * scip, SCIP_VAR * var)
+    SCIP_RETCODE SCIPaddSolFree(SCIP* scip, SCIP_SOL** sol, SCIP_Bool* stored)
+    SCIP_RETCODE SCIPaddSol(SCIP* scip, SCIP_SOL* sol, SCIP_Bool* stored)
+    SCIP_RETCODE SCIPreadSol(SCIP* scip, const char* filename)
+    SCIP_RETCODE SCIPreadSolFile(SCIP* scip, const char* filename, SCIP_SOL* sol, SCIP_Bool xml, SCIP_Bool*	partial, SCIP_Bool*	error)
+    SCIP_RETCODE SCIPcheckSol(SCIP* scip, SCIP_SOL* sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool* feasible)
+    SCIP_RETCODE SCIPcheckSolOrig(SCIP* scip, SCIP_SOL* sol, SCIP_Bool* feasible, SCIP_Bool printreason, SCIP_Bool completely)
+
+    SCIP_Real SCIPgetSolTime(SCIP* scip, SCIP_SOL* sol)
+
+    SCIP_RETCODE SCIPsetRelaxSolVal(SCIP* scip, SCIP_RELAX* relax, SCIP_VAR* var, SCIP_Real val)
+
+    # Row Methods
+    SCIP_RETCODE SCIPcreateRow(SCIP* scip, SCIP_ROW** row, const char* name, int len, SCIP_COL** cols, SCIP_Real* vals,
+                               SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
+    SCIP_RETCODE SCIPaddRow(SCIP* scip, SCIP_ROW* row, SCIP_Bool forcecut, SCIP_Bool* infeasible)
+    SCIP_RETCODE SCIPcreateEmptyRowSepa(SCIP* scip, SCIP_ROW** row, SCIP_SEPA* sepa, const char* name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
+    SCIP_RETCODE SCIPcreateEmptyRowUnspec(SCIP* scip, SCIP_ROW** row, const char* name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
+    SCIP_Real SCIPgetRowActivity(SCIP* scip, SCIP_ROW* row)
+    SCIP_Real SCIPgetRowLPActivity(SCIP* scip, SCIP_ROW* row)
+    SCIP_RETCODE SCIPreleaseRow(SCIP* scip, SCIP_ROW** row)
+    SCIP_RETCODE SCIPcacheRowExtensions(SCIP* scip, SCIP_ROW* row)
+    SCIP_RETCODE SCIPflushRowExtensions(SCIP* scip, SCIP_ROW* row)
+    SCIP_RETCODE SCIPaddVarToRow(SCIP* scip, SCIP_ROW* row, SCIP_VAR* var, SCIP_Real val)
+    SCIP_RETCODE SCIPprintRow(SCIP* scip, SCIP_ROW* row, FILE* file)
+    int SCIPgetRowNumIntCols(SCIP* scip, SCIP_ROW* row)
+    int SCIProwGetNNonz(SCIP_ROW* row)
+    SCIP_Real SCIPgetRowObjParallelism(SCIP* scip, SCIP_ROW* row)
+
+    # Column Methods
+    SCIP_Real SCIPgetColRedcost(SCIP* scip, SCIP_COL* col)
+
+    # Dual Solution Methods
+    SCIP_Real SCIPgetDualbound(SCIP* scip)
+    SCIP_Real SCIPgetDualboundRoot(SCIP* scip)
+    SCIP_Real SCIPgetVarRedcost(SCIP* scip, SCIP_VAR* var)
+    SCIP_RETCODE SCIPgetDualSolVal(SCIP* scip, SCIP_CONS* cons, SCIP_Real* dualsolval, SCIP_Bool* boundconstraint)
+
+    # Reader plugin
+    SCIP_RETCODE SCIPincludeReader(SCIP* scip,
+                                   const char* name,
+                                   const char* desc,
+                                   const char* extension,
+                                   SCIP_RETCODE (*readercopy) (SCIP* scip, SCIP_READER* reader),
+                                   SCIP_RETCODE (*readerfree) (SCIP* scip, SCIP_READER* reader),
+                                   SCIP_RETCODE (*readerread) (SCIP* scip, SCIP_READER* reader, const char* filename, SCIP_RESULT* result),
+                                   SCIP_RETCODE (*readerwrite) (SCIP* scip, SCIP_READER* reader, FILE* file,
+                                                                const char* name, SCIP_PROBDATA* probdata, SCIP_Bool transformed,
+                                                                SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset,
+                                                                SCIP_VAR** vars, int nvars, int nbinvars, int nintvars, int nimplvars, int ncontvars,
+                                                                SCIP_VAR** fixedvars, int nfixedvars, int startnvars,
+                                                                SCIP_CONS** conss, int nconss, int maxnconss, int startnconss,
+                                                                SCIP_Bool genericnames, SCIP_RESULT* result),
+                                   SCIP_READERDATA* readerdata)
+    SCIP_READER* SCIPfindReader(SCIP* scip, const char* name)
+    SCIP_READERDATA* SCIPreaderGetData(SCIP_READER* reader)
+    int SCIPgetNReaders(SCIP* scip)
+
+    # Event handler plugin
+    SCIP_RETCODE SCIPincludeEventhdlr(SCIP* scip,
+                                      const char* name,
+                                      const char* desc,
+                                      SCIP_RETCODE (*eventcopy) (SCIP* scip, SCIP_EVENTHDLR* eventhdlr),
+                                      SCIP_RETCODE (*eventfree) (SCIP* scip, SCIP_EVENTHDLR* eventhdlr),
+                                      SCIP_RETCODE (*eventinit) (SCIP* scip, SCIP_EVENTHDLR* eventhdlr),
+                                      SCIP_RETCODE (*eventexit) (SCIP* scip, SCIP_EVENTHDLR* eventhdlr),
+                                      SCIP_RETCODE (*eventinitsol) (SCIP* scip, SCIP_EVENTHDLR* eventhdlr),
+                                      SCIP_RETCODE (*eventexitsol) (SCIP* scip, SCIP_EVENTHDLR* eventhdlr),
+                                      SCIP_RETCODE (*eventdelete) (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENTDATA** eventdata),
+                                      SCIP_RETCODE (*eventexec) (SCIP* scip, SCIP_EVENTHDLR* eventhdlr, SCIP_EVENT* event, SCIP_EVENTDATA* eventdata),
+                                      SCIP_EVENTHDLRDATA* eventhdlrdata)
+    SCIP_EVENTHDLRDATA* SCIPeventhdlrGetData(SCIP_EVENTHDLR* eventhdlr)
+
+    # Variable pricer plugin
+    SCIP_RETCODE SCIPincludePricer(SCIP* scip,
+                                   const char*  name,
+                                   const char*  desc,
+                                   int priority,
+                                   SCIP_Bool delay,
+                                   SCIP_RETCODE (*pricercopy) (SCIP* scip, SCIP_PRICER* pricer, SCIP_Bool* valid),
+                                   SCIP_RETCODE (*pricerfree) (SCIP* scip, SCIP_PRICER* pricer),
+                                   SCIP_RETCODE (*pricerinit) (SCIP* scip, SCIP_PRICER* pricer),
+                                   SCIP_RETCODE (*pricerexit) (SCIP* scip, SCIP_PRICER* pricer),
+                                   SCIP_RETCODE (*pricerinitsol) (SCIP* scip, SCIP_PRICER* pricer),
+                                   SCIP_RETCODE (*pricerexitsol) (SCIP* scip, SCIP_PRICER* pricer),
+                                   SCIP_RETCODE (*pricerredcost) (SCIP* scip, SCIP_PRICER* pricer, SCIP_Real* lowerbound, SCIP_Bool* stopearly, SCIP_RESULT* result),
+                                   SCIP_RETCODE (*pricerfarkas) (SCIP* scip, SCIP_PRICER* pricer, SCIP_RESULT* result),
+                                   SCIP_PRICERDATA* pricerdata)
+    SCIP_PRICER* SCIPfindPricer(SCIP* scip, const char* name)
+    SCIP_RETCODE SCIPactivatePricer(SCIP* scip, SCIP_PRICER* pricer)
+    SCIP_PRICERDATA* SCIPpricerGetData(SCIP_PRICER* pricer)
+
+    # Constraint handler plugin
+    SCIP_RETCODE SCIPincludeConshdlr(SCIP* scip,
+                                     const char* name,
+                                     const char* desc,
+                                     int sepapriority,
+                                     int enfopriority,
+                                     int chckpriority,
+                                     int sepafreq,
+                                     int propfreq,
+                                     int eagerfreq,
+                                     int maxprerounds,
+                                     SCIP_Bool delaysepa,
+                                     SCIP_Bool delayprop,
+                                     SCIP_Bool needscons,
+                                     SCIP_PROPTIMING proptiming,
+                                     SCIP_PRESOLTIMING presoltiming,
+                                     SCIP_RETCODE (*conshdlrcopy) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid),
+                                     SCIP_RETCODE (*consfree) (SCIP* scip, SCIP_CONSHDLR* conshdlr),
+                                     SCIP_RETCODE (*consinit) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss),
+                                     SCIP_RETCODE (*consexit) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss),
+                                     SCIP_RETCODE (*consinitpre) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss),
+                                     SCIP_RETCODE (*consexitpre) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss),
+                                     SCIP_RETCODE (*consinitsol) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss),
+                                     SCIP_RETCODE (*consexitsol) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart),
+                                     SCIP_RETCODE (*consdelete) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata),
+                                     SCIP_RETCODE (*constrans) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons),
+                                     SCIP_RETCODE (*consinitlp) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible),
+                                     SCIP_RETCODE (*conssepalp) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*conssepasol) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_SOL* sol, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*consenfolp) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_Bool solinfeasible, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*consenforelax) (SCIP* scip, SCIP_SOL* sol, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_Bool solinfeasible, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*consenfops) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*conscheck) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*consprop) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss, SCIP_PROPTIMING proptiming, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*conspresol) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes, int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*consresprop) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR* infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result),
+                                     SCIP_RETCODE (*conslock) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg),
+                                     SCIP_RETCODE (*consactive) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons),
+                                     SCIP_RETCODE (*consdeactive) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons),
+                                     SCIP_RETCODE (*consenable) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons),
+                                     SCIP_RETCODE (*consdisable) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons),
+                                     SCIP_RETCODE (*consdelvars) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss),
+                                     SCIP_RETCODE (*consprint) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file),
+                                     SCIP_RETCODE (*conscopy) (SCIP* scip, SCIP_CONS** cons, const char* name, SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr, SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, 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, SCIP_Bool py_global, SCIP_Bool* valid),
+                                     SCIP_RETCODE (*consparse) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, const char* name, const char* str, 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, SCIP_Bool* success),
+                                     SCIP_RETCODE (*consgetvars) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_VAR** vars, int varssize, SCIP_Bool* success),
+                                     SCIP_RETCODE (*consgetnvars) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, int* nvars, SCIP_Bool* success),
+                                     SCIP_RETCODE (*consgetdivebdchgs) (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, SCIP_SOL* sol, SCIP_Bool* success, SCIP_Bool* infeasible),
+                                     SCIP_RETCODE (*consgetpermsymgraph)(SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SYM_GRAPH* graph, SCIP_Bool* success),
+                                     SCIP_RETCODE (*consgetsignedpermsymgraph)(SCIP * scip, SCIP_CONSHDLR * conshdlr, SCIP_CONS * cons, SYM_GRAPH * graph, SCIP_Bool * success),
+                                     SCIP_CONSHDLRDATA* conshdlrdata)
+    SCIP_CONSHDLRDATA* SCIPconshdlrGetData(SCIP_CONSHDLR* conshdlr)
+    SCIP_CONSHDLR* SCIPfindConshdlr(SCIP* scip, const char* name)
+    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)
+
+    # Presolve plugin
+    SCIP_RETCODE SCIPincludePresol(SCIP* scip,
+                                   const char* name,
+                                   const char* desc,
+                                   int priority,
+                                   int maxrounds,
+                                   SCIP_PRESOLTIMING timing,
+                                   SCIP_RETCODE (*presolcopy) (SCIP* scip, SCIP_PRESOL* presol),
+                                   SCIP_RETCODE (*presolfree) (SCIP* scip, SCIP_PRESOL* presol),
+                                   SCIP_RETCODE (*presolinit) (SCIP* scip, SCIP_PRESOL* presol),
+                                   SCIP_RETCODE (*presolexit) (SCIP* scip, SCIP_PRESOL* presol),
+                                   SCIP_RETCODE (*presolinitpre) (SCIP* scip, SCIP_PRESOL* presol),
+                                   SCIP_RETCODE (*presolexitpre) (SCIP* scip, SCIP_PRESOL* presol),
+                                   SCIP_RETCODE (*presolexec) (SCIP* scip, SCIP_PRESOL* presol, int nrounds, SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes, int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result),
+                                   SCIP_PRESOLDATA* presoldata)
+    SCIP_PRESOLDATA* SCIPpresolGetData(SCIP_PRESOL* presol)
+
+    # Separator plugin
+    SCIP_RETCODE SCIPincludeSepa(SCIP* scip,
+                                 const char* name,
+                                 const char* desc,
+                                 int priority,
+                                 int freq,
+                                 SCIP_Real maxbounddist,
+                                 SCIP_Bool usessubscip,
+                                 SCIP_Bool delay,
+                                 SCIP_RETCODE (*sepacopy) (SCIP* scip, SCIP_SEPA* sepa),
+                                 SCIP_RETCODE (*sepafree) (SCIP* scip, SCIP_SEPA* sepa),
+                                 SCIP_RETCODE (*sepainit) (SCIP* scip, SCIP_SEPA* sepa),
+                                 SCIP_RETCODE (*sepaexit) (SCIP* scip, SCIP_SEPA* sepa),
+                                 SCIP_RETCODE (*sepainitsol) (SCIP* scip, SCIP_SEPA* sepa),
+                                 SCIP_RETCODE (*sepaexitsol) (SCIP* scip, SCIP_SEPA* sepa),
+                                 SCIP_RETCODE (*sepaexeclp) (SCIP* scip, SCIP_SEPA* sepa, SCIP_RESULT* result, unsigned int allowlocal, int depth),
+                                 SCIP_RETCODE (*sepaexecsol) (SCIP* scip, SCIP_SEPA* sepa, SCIP_SOL* sol, SCIP_RESULT* result, unsigned int allowlocal, int depth),
+                                 SCIP_SEPADATA* sepadata)
+    SCIP_SEPADATA* SCIPsepaGetData(SCIP_SEPA* sepa)
+    SCIP_SEPA* SCIPfindSepa(SCIP* scip, const char* name)
+
+    # Propagator plugin
+    SCIP_RETCODE SCIPincludeProp(SCIP* scip,
+                                 const char*  name,
+                                 const char*  desc,
+                                 int priority,
+                                 int freq,
+                                 SCIP_Bool delay,
+                                 SCIP_PROPTIMING timingmask,
+                                 int presolpriority,
+                                 int presolmaxrounds,
+                                 SCIP_PRESOLTIMING presoltiming,
+                                 SCIP_RETCODE (*propcopy) (SCIP* scip, SCIP_PROP* prop),
+                                 SCIP_RETCODE (*propfree) (SCIP* scip, SCIP_PROP* prop),
+                                 SCIP_RETCODE (*propinit) (SCIP* scip, SCIP_PROP* prop),
+                                 SCIP_RETCODE (*propexit) (SCIP* scip, SCIP_PROP* prop),
+                                 SCIP_RETCODE (*propinitpre) (SCIP* scip, SCIP_PROP* prop),
+                                 SCIP_RETCODE (*propexitpre) (SCIP* scip, SCIP_PROP* prop),
+                                 SCIP_RETCODE (*propinitsol) (SCIP* scip, SCIP_PROP* prop),
+                                 SCIP_RETCODE (*propexitsol) (SCIP* scip, SCIP_PROP* prop, SCIP_Bool restart),
+                                 SCIP_RETCODE (*proppresol)  (SCIP* scip, SCIP_PROP* prop, int nrounds, SCIP_PRESOLTIMING presoltiming,
+                                                               int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes,
+                                                               int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides,
+                                                               int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes,
+                                                               int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result),
+                                 SCIP_RETCODE (*propexec) (SCIP* scip, SCIP_PROP* prop, SCIP_PROPTIMING proptiming, SCIP_RESULT* result),
+                                 SCIP_RETCODE (*propresprop) (SCIP* scip, SCIP_PROP* prop, SCIP_VAR* infervar, int inferinfo,
+                                                               SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT* result),
+                                 SCIP_PROPDATA*  propdata)
+
+    SCIP_PROPDATA* SCIPpropGetData (SCIP_PROP* prop)
+
+    # Heuristics plugin
+    SCIP_RETCODE SCIPincludeHeur(SCIP* scip,
+                                 const char* name,
+                                 const char* desc,
+                                 char dispchar,
+                                 int priority,
+                                 int freq,
+                                 int freqofs,
+                                 int maxdepth,
+                                 unsigned int timingmask,
+                                 SCIP_Bool usessubscip,
+                                 SCIP_RETCODE (*heurcopy) (SCIP* scip, SCIP_HEUR* heur),
+                                 SCIP_RETCODE (*heurfree) (SCIP* scip, SCIP_HEUR* heur),
+                                 SCIP_RETCODE (*heurinit) (SCIP* scip, SCIP_HEUR* heur),
+                                 SCIP_RETCODE (*heurexit) (SCIP* scip, SCIP_HEUR* heur),
+                                 SCIP_RETCODE (*heurinitsol) (SCIP* scip, SCIP_HEUR* heur),
+                                 SCIP_RETCODE (*heurexitsol) (SCIP* scip, SCIP_HEUR* heur),
+                                 SCIP_RETCODE (*heurexec) (SCIP* scip, SCIP_HEUR* heur, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_RESULT* result),
+                                 SCIP_HEURDATA* heurdata)
+    SCIP_HEURDATA* SCIPheurGetData(SCIP_HEUR* heur)
+    SCIP_HEUR* SCIPfindHeur(SCIP* scip, const char* name)
+
+    #Relaxation plugin
+    SCIP_RETCODE SCIPincludeRelax(SCIP* scip,
+		                         const char* name,
+                           		 const char* desc,
+		                         int priority,
+		                         int freq,
+		                         SCIP_RETCODE (*relaxcopy) (SCIP* scip, SCIP_RELAX* relax),
+                                 SCIP_RETCODE (*relaxfree) (SCIP* scip, SCIP_RELAX* relax),
+                                 SCIP_RETCODE (*relaxinit) (SCIP* scip, SCIP_RELAX* relax),
+                                 SCIP_RETCODE (*relaxexit) (SCIP* scip, SCIP_RELAX* relax),
+                                 SCIP_RETCODE (*relaxinitsol) (SCIP* scip, SCIP_RELAX* relax),
+                                 SCIP_RETCODE (*relaxexitsol) (SCIP* scip, SCIP_RELAX* relax),
+                                 SCIP_RETCODE (*relaxexec) (SCIP* scip, SCIP_RELAX* relax, SCIP_Real* lowerbound, SCIP_RESULT* result),
+                                 SCIP_RELAXDATA* relaxdata)
+    SCIP_RELAXDATA* SCIPrelaxGetData(SCIP_RELAX* relax)
+    SCIP_RELAX* SCIPfindRelax(SCIP* scip, const char* name)
+
+    # Node selection plugin
+    SCIP_RETCODE SCIPincludeNodesel(SCIP* scip,
+                                    const char* name,
+                                    const char* desc,
+                                    int stdpriority,
+                                    int memsavepriority,
+                                    SCIP_RETCODE (*nodeselcopy) (SCIP* scip, SCIP_NODESEL* nodesel),
+                                    SCIP_RETCODE (*nodeselfree) (SCIP* scip, SCIP_NODESEL* nodesel),
+                                    SCIP_RETCODE (*nodeselinit) (SCIP* scip, SCIP_NODESEL* nodesel),
+                                    SCIP_RETCODE (*nodeselexit) (SCIP* scip, SCIP_NODESEL* nodesel),
+                                    SCIP_RETCODE (*nodeselinitsol) (SCIP* scip, SCIP_NODESEL* nodesel),
+                                    SCIP_RETCODE (*nodeselexitsol) (SCIP* scip, SCIP_NODESEL* nodesel),
+                                    SCIP_RETCODE (*nodeselselect) (SCIP* scip, SCIP_NODESEL* nodesel, SCIP_NODE** selnode),
+                                    int (*nodeselcomp) (SCIP* scip, SCIP_NODESEL* nodesel,  SCIP_NODE* node1, SCIP_NODE* node2),
+                                    SCIP_NODESELDATA* nodeseldata)
+    SCIP_NODESELDATA* SCIPnodeselGetData(SCIP_NODESEL* nodesel)
+
+    # Branching rule plugin
+    SCIP_RETCODE SCIPincludeBranchrule(SCIP* scip,
+                                       const char* name,
+                                       const char* desc,
+                                       int priority,
+                                       int maxdepth,
+                                       SCIP_Real maxbounddist,
+                                       SCIP_RETCODE (*branchrulecopy) (SCIP* scip, SCIP_BRANCHRULE* branchrule),
+                                       SCIP_RETCODE (*branchrulefree) (SCIP* scip, SCIP_BRANCHRULE* branchrule),
+                                       SCIP_RETCODE (*branchruleinit) (SCIP* scip, SCIP_BRANCHRULE* branchrule),
+                                       SCIP_RETCODE (*branchruleexit) (SCIP* scip, SCIP_BRANCHRULE* branchrule),
+                                       SCIP_RETCODE (*branchruleinitsol) (SCIP* scip, SCIP_BRANCHRULE* branchrule),
+                                       SCIP_RETCODE (*branchruleexitsol) (SCIP* scip, SCIP_BRANCHRULE* branchrule),
+                                       SCIP_RETCODE (*branchruleexeclp) (SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result),
+                                       SCIP_RETCODE (*branchruleexecext) (SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result),
+                                       SCIP_RETCODE (*branchruleexecps) (SCIP* scip, SCIP_BRANCHRULE* branchrule, SCIP_Bool allowaddcons, SCIP_RESULT* result),
+                                       SCIP_BRANCHRULEDATA* branchruledata)
+    SCIP_BRANCHRULEDATA* SCIPbranchruleGetData(SCIP_BRANCHRULE* branchrule)
+    const char* SCIPbranchruleGetName(SCIP_BRANCHRULE* branchrule)
+    SCIP_BRANCHRULE* SCIPfindBranchrule(SCIP* scip, const char*  name)
+
+    # cut selector plugin
+    SCIP_RETCODE SCIPincludeCutsel(SCIP* scip,
+                                   const char* name,
+                                   const char* desc,
+                                   int priority,
+                                   SCIP_RETCODE (*cutselcopy) (SCIP* scip, SCIP_CUTSEL* cutsel),
+                                   SCIP_RETCODE (*cutselfree) (SCIP* scip, SCIP_CUTSEL* cutsel),
+                                   SCIP_RETCODE (*cutselinit) (SCIP* scip, SCIP_CUTSEL* cutsel),
+                                   SCIP_RETCODE (*cutselexit) (SCIP* scip, SCIP_CUTSEL* cutsel),
+                                   SCIP_RETCODE (*cutselinitsol) (SCIP* scip, SCIP_CUTSEL* cutsel),
+                                   SCIP_RETCODE (*cutselexitsol) (SCIP* scip, SCIP_CUTSEL* cutsel),
+                                   SCIP_RETCODE (*cutselselect) (SCIP* scip, SCIP_CUTSEL* cutsel, SCIP_ROW** cuts,
+                                                                 int ncuts, SCIP_ROW** forcedcuts, int nforcedcuts,
+                                                                 SCIP_Bool root, int maxnselectedcuts,
+                                                                 int* nselectedcuts, SCIP_RESULT* result),
+                                   SCIP_CUTSELDATA* cutseldata)
+    SCIP_CUTSELDATA* SCIPcutselGetData(SCIP_CUTSEL* cutsel)
+
+    # Benders' decomposition plugin
+    SCIP_RETCODE SCIPincludeBenders(SCIP* scip,
+                                   const char*  name,
+                                   const char*  desc,
+                                   int priority,
+                                   SCIP_Bool cutlp,
+                                   SCIP_Bool cutpseudo,
+                                   SCIP_Bool cutrelax,
+                                   SCIP_Bool shareaux,
+                                   SCIP_RETCODE (*benderscopy) (SCIP* scip, SCIP_BENDERS* benders, SCIP_Bool threadsafe),
+                                   SCIP_RETCODE (*bendersfree) (SCIP* scip, SCIP_BENDERS* benders),
+                                   SCIP_RETCODE (*bendersinit) (SCIP* scip, SCIP_BENDERS* benders),
+                                   SCIP_RETCODE (*bendersexit) (SCIP* scip, SCIP_BENDERS* benders),
+                                   SCIP_RETCODE (*bendersinitpre) (SCIP* scip, SCIP_BENDERS* benders),
+                                   SCIP_RETCODE (*bendersexitpre) (SCIP* scip, SCIP_BENDERS* benders),
+                                   SCIP_RETCODE (*bendersinitsol) (SCIP* scip, SCIP_BENDERS* benders),
+                                   SCIP_RETCODE (*bendersexitsol) (SCIP* scip, SCIP_BENDERS* benders),
+                                   SCIP_RETCODE (*bendersgetvar) (SCIP* scip, SCIP_BENDERS* benders, SCIP_VAR* var, SCIP_VAR** mappedvar, int probnumber),
+                                   SCIP_RETCODE (*benderscreatesub) (SCIP* scip, SCIP_BENDERS* benders, int probnumber),
+                                   SCIP_RETCODE (*benderspresubsolve) (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, SCIP_BENDERSENFOTYPE type, SCIP_Bool checkint, SCIP_Bool* infeasible, SCIP_Bool* auxviol, SCIP_Bool* skipsolve,  SCIP_RESULT* result),
+                                   SCIP_RETCODE (*benderssolvesubconvex) (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Bool onlyconvex, SCIP_Real* objective, SCIP_RESULT* result),
+                                   SCIP_RETCODE (*benderssolvesub) (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Real* objective, SCIP_RESULT* result),
+                                   SCIP_RETCODE (*benderspostsolve) (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, SCIP_BENDERSENFOTYPE type, int* mergecands, int npriomergecands, int nmergecands, SCIP_Bool checkint, SCIP_Bool infeasible, SCIP_Bool* merged),
+                                   SCIP_RETCODE (*bendersfreesub) (SCIP* scip, SCIP_BENDERS* benders, int probnumber),
+                                   SCIP_BENDERSDATA* bendersdata)
+    SCIP_BENDERS* SCIPfindBenders(SCIP* scip, const char* name)
+    SCIP_RETCODE SCIPactivateBenders(SCIP* scip, SCIP_BENDERS* benders, int nsubproblems)
+    SCIP_BENDERSDATA* SCIPbendersGetData(SCIP_BENDERS* benders)
+    SCIP_RETCODE SCIPcreateBendersDefault(SCIP* scip, SCIP** subproblems, int nsubproblems)
+    int SCIPbendersGetNSubproblems(SCIP_BENDERS* benders)
+    SCIP_RETCODE SCIPsolveBendersSubproblems(SCIP* scip, SCIP_BENDERS* benders,
+            SCIP_SOL* sol, SCIP_RESULT* result, SCIP_Bool* infeasible,
+            SCIP_Bool* auxviol, SCIP_Bool checkint)
+    SCIP_RETCODE SCIPsetupBendersSubproblem(SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber,
+            SCIP_BENDERSENFOTYPE type)
+    SCIP_RETCODE SCIPsolveBendersSubproblem(SCIP* scip, SCIP_BENDERS* benders,
+            SCIP_SOL* sol, int probnumber, SCIP_Bool* infeasible,
+            SCIP_Bool solvecip, SCIP_Real* objective)
+    SCIP_RETCODE SCIPfreeBendersSubproblem(SCIP* scip, SCIP_BENDERS* benders, int probnumber)
+    int SCIPgetNActiveBenders(SCIP* scip)
+    SCIP_BENDERS** SCIPgetBenders(SCIP* scip)
+    void SCIPbendersUpdateSubproblemLowerbound(SCIP_BENDERS* benders, int probnumber, SCIP_Real lowerbound)
+    SCIP_RETCODE SCIPaddBendersSubproblem(SCIP* scip, SCIP_BENDERS* benders, SCIP* subproblem)
+    SCIP* SCIPbendersSubproblem(SCIP_BENDERS* benders, int probnumber)
+    SCIP_RETCODE SCIPgetBendersMasterVar(SCIP* scip, SCIP_BENDERS* benders, SCIP_VAR* var, SCIP_VAR** mappedvar)
+    SCIP_RETCODE SCIPgetBendersSubproblemVar(SCIP* scip, SCIP_BENDERS* benders, SCIP_VAR* var, SCIP_VAR** mappedvar, int probnumber)
+    SCIP_VAR* SCIPbendersGetAuxiliaryVar(SCIP_BENDERS* benders, int probnumber)
+    SCIP_RETCODE SCIPcheckBendersSubproblemOptimality(SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol, int probnumber, SCIP_Bool* optimal)
+    SCIP_RETCODE SCIPincludeBendersDefaultCuts(SCIP* scip, SCIP_BENDERS* benders)
+    void SCIPbendersSetSubproblemIsConvex(SCIP_BENDERS* benders, int probnumber, SCIP_Bool isconvex)
+
+    # Benders' decomposition cuts plugin
+    SCIP_RETCODE SCIPincludeBenderscut(SCIP* scip,
+                                      SCIP_BENDERS* benders,
+                                      const char*  name,
+                                      const char*  desc,
+                                      int priority,
+                                      SCIP_Bool islpcut,
+                                      SCIP_RETCODE (*benderscutcopy) (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut),
+                                      SCIP_RETCODE (*benderscutfree) (SCIP* scip, SCIP_BENDERSCUT* benderscut),
+                                      SCIP_RETCODE (*benderscutinit) (SCIP* scip, SCIP_BENDERSCUT* benderscut),
+                                      SCIP_RETCODE (*benderscutexit) (SCIP* scip, SCIP_BENDERSCUT* benderscut),
+                                      SCIP_RETCODE (*benderscutinitsol) (SCIP* scip, SCIP_BENDERSCUT* benderscut),
+                                      SCIP_RETCODE (*benderscutexitsol) (SCIP* scip, SCIP_BENDERSCUT* benderscut),
+                                      SCIP_RETCODE (*benderscutexec) (SCIP* scip, SCIP_BENDERS* benders, SCIP_BENDERSCUT* benderscut, SCIP_SOL* sol, int probnumber, SCIP_BENDERSENFOTYPE type, SCIP_RESULT* result),
+                                      SCIP_BENDERSCUTDATA* benderscutdata)
+    SCIP_BENDERSCUT* SCIPfindBenderscut(SCIP_BENDERS* benders, const char* name)
+    SCIP_BENDERSCUTDATA* SCIPbenderscutGetData(SCIP_BENDERSCUT* benderscut)
+    SCIP_RETCODE SCIPstoreBendersCut(SCIP* scip, SCIP_BENDERS* benders, SCIP_VAR** vars, SCIP_Real* vals, SCIP_Real lhs, SCIP_Real rhs, int nvars)
+    SCIP_RETCODE SCIPapplyBendersStoredCuts(SCIP* scip, SCIP_BENDERS* benders)
+
+    SCIP_RETCODE SCIPbranchVar(SCIP* scip,
+                                SCIP_VAR* var,
+                                SCIP_NODE**  downchild,
+                                SCIP_NODE**  eqchild,
+                                SCIP_NODE**  upchild)
+
+    SCIP_RETCODE SCIPbranchVarVal(SCIP* scip,
+                                SCIP_VAR* var,
+                                SCIP_Real val,
+                                SCIP_NODE** downchild,
+                                SCIP_NODE**  eqchild,
+                                SCIP_NODE** upchild)
+    int SCIPgetNLPBranchCands(SCIP* scip)
+    SCIP_RETCODE SCIPgetLPBranchCands(SCIP* scip, SCIP_VAR*** lpcands, SCIP_Real** lpcandssol,
+                                      SCIP_Real** lpcandsfrac, int* nlpcands, int* npriolpcands, int* nfracimplvars)
+    SCIP_RETCODE SCIPgetPseudoBranchCands(SCIP* scip, SCIP_VAR*** pseudocands, int* npseudocands, int* npriopseudocands)
+
+
+    # Numerical Methods
+    SCIP_Real SCIPinfinity(SCIP* scip)
+    SCIP_Real SCIPfrac(SCIP* scip, SCIP_Real val)
+    SCIP_Real SCIPfeasFrac(SCIP* scip, SCIP_Real val)
+    SCIP_Bool SCIPisZero(SCIP* scip, SCIP_Real val)
+    SCIP_Bool SCIPisFeasIntegral(SCIP* scip, SCIP_Real val)
+    SCIP_Bool SCIPisFeasZero(SCIP* scip, SCIP_Real val)
+    SCIP_Bool SCIPisFeasNegative(SCIP* scip, SCIP_Real val)
+    SCIP_Bool SCIPisInfinity(SCIP* scip, SCIP_Real val)
+    SCIP_Bool SCIPisLE(SCIP* scip, SCIP_Real val1, SCIP_Real val2)
+    SCIP_Bool SCIPisLT(SCIP* scip, SCIP_Real val1, SCIP_Real val2)
+    SCIP_Bool SCIPisGE(SCIP* scip, SCIP_Real val1, SCIP_Real val2)
+    SCIP_Bool SCIPisGT(SCIP* scip, SCIP_Real val1, SCIP_Real val2)
+    SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
+    SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
+    SCIP_Bool SCIPisHugeValue(SCIP *scip, SCIP_Real val)
+    SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
+    SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
+    SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
+    SCIP_Real SCIPgetTreesizeEstimation(SCIP *scip)
+
+    # Statistic Methods
+    SCIP_RETCODE SCIPprintStatistics(SCIP* scip, FILE* outfile)
+    SCIP_Longint SCIPgetNNodes(SCIP* scip)
+    SCIP_Longint SCIPgetNTotalNodes(SCIP* scip)
+    SCIP_Longint SCIPgetNFeasibleLeaves(SCIP* scip)
+    SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP* scip)
+    SCIP_Longint SCIPgetNLPs(SCIP* scip)
+    SCIP_Longint SCIPgetNLPIterations(SCIP* scip)
+    int SCIPgetNSepaRounds(SCIP* scip)
+
+    # Parameter Functions
+    SCIP_RETCODE SCIPsetBoolParam(SCIP* scip, char* name, SCIP_Bool value)
+    SCIP_RETCODE SCIPsetIntParam(SCIP* scip, char* name, int value)
+    SCIP_RETCODE SCIPsetLongintParam(SCIP* scip, char* name, SCIP_Longint value)
+    SCIP_RETCODE SCIPsetRealParam(SCIP* scip, char* name, SCIP_Real value)
+    SCIP_RETCODE SCIPsetCharParam(SCIP* scip, char* name, char value)
+    SCIP_RETCODE SCIPsetStringParam(SCIP* scip, char* name, char* value)
+    SCIP_RETCODE SCIPreadParams(SCIP* scip, char* file)
+    SCIP_RETCODE SCIPwriteParams(SCIP* scip, char* file, SCIP_Bool comments, SCIP_Bool onlychanged)
+    SCIP_RETCODE SCIPreadProb(SCIP* scip, char* file, char* extension)
+    SCIP_RETCODE SCIPsetEmphasis(SCIP* scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
+    SCIP_RETCODE SCIPresetParam(SCIP* scip, const char* name)
+    SCIP_RETCODE SCIPresetParams(SCIP* scip)
+    SCIP_PARAM* SCIPgetParam(SCIP* scip,  const char*  name)
+    SCIP_PARAM** SCIPgetParams(SCIP* scip)
+    int SCIPgetNParams(SCIP* scip)
+
+    # LPI Functions
+    SCIP_RETCODE SCIPgetLPI(SCIP* scip, SCIP_LPI** lpi)
+    SCIP_RETCODE SCIPlpiCreate(SCIP_LPI** lpi, SCIP_MESSAGEHDLR* messagehdlr, const char* name, SCIP_OBJSEN objsen)
+    SCIP_RETCODE SCIPlpiFree(SCIP_LPI** lpi)
+    SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI* lpi, const char* fname)
+    SCIP_RETCODE SCIPlpiReadLP(SCIP_LPI* lpi, const char* fname)
+    SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI* lpi, int ncols, const SCIP_Real* obj, const SCIP_Real* lb, const SCIP_Real* ub, char** colnames, int nnonz, const int* beg, const int* ind, const SCIP_Real* val)
+    SCIP_RETCODE SCIPlpiDelCols(SCIP_LPI* lpi, int firstcol, int lastcol)
+    SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI* lpi, int nrows, const SCIP_Real* lhs, const SCIP_Real* rhs, char** rownames, int nnonz, const int* beg, const int* ind, const SCIP_Real* val)
+    SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI* lpi, int firstrow, int lastrow)
+    SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI* lpi, int firstrow, int lastrow, SCIP_Real* lhss, SCIP_Real* rhss)
+    SCIP_RETCODE SCIPlpiGetSides(SCIP_LPI* lpi, int firstcol, int lastcol, SCIP_Real* lbs, SCIP_Real* ubs)
+    SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI* lpi, int ncols, int* ind, SCIP_Real* obj)
+    SCIP_RETCODE SCIPlpiChgCoef(SCIP_LPI* lpi, int row, int col, SCIP_Real newval)
+    SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI* lpi, int nrows, const int* ind, const SCIP_Real* lhs, const SCIP_Real* rhs)
+    SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI* lpi, int ncols, const int* ind, const SCIP_Real* lbs, const SCIP_Real* ubs)
+    SCIP_RETCODE SCIPlpiClear(SCIP_LPI* lpi)
+    SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI* lpi, int* nrows)
+    SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI* lpi, int* ncols)
+    SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI* lpi)
+    SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI* lpi)
+    SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI* lpi, SCIP_Real* objval)
+    SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI* lpi, SCIP_Real* objval, SCIP_Real* primsol, SCIP_Real* dualsol, SCIP_Real* activity, SCIP_Real* redcost)
+    SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI* lpi, int* iterations)
+    SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI* lpi, SCIP_Real* ray)
+    SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI* lpi, SCIP_Real* dualfarkas)
+    SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI* lpi, int* bind)
+    SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI* lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real* quality)
+    SCIP_Bool    SCIPlpiHasPrimalRay(SCIP_LPI* lpi)
+    SCIP_Bool    SCIPlpiHasDualRay(SCIP_LPI* lpi)
+    SCIP_Real    SCIPlpiInfinity(SCIP_LPI* lpi)
+    SCIP_Bool    SCIPlpiIsInfinity(SCIP_LPI* lpi, SCIP_Real val)
+    SCIP_Bool    SCIPlpiIsPrimalFeasible(SCIP_LPI* lpi)
+    SCIP_Bool    SCIPlpiIsDualFeasible(SCIP_LPI* lpi)
+
+    #re-optimization routines
+    SCIP_RETCODE SCIPfreeReoptSolve(SCIP* scip)
+    SCIP_RETCODE SCIPchgReoptObjective(SCIP* scip, SCIP_OBJSENSE objsense, SCIP_VAR** vars, SCIP_Real* coefs, int nvars)
+    SCIP_RETCODE SCIPenableReoptimization(SCIP* scip, SCIP_Bool enable)
+
+    BMS_BLKMEM* SCIPblkmem(SCIP* scip)
+
+cdef extern from "scip/tree.h":
+    int SCIPnodeGetNAddedConss(SCIP_NODE* node)
+
+cdef extern from "scip/scipdefplugins.h":
+    SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP* scip)
+
+cdef extern from "scip/bendersdefcuts.h":
+    SCIP_RETCODE SCIPincludeBendersDefaultCuts(SCIP* scip, SCIP_BENDERS* benders)
+
+cdef extern from "scip/cons_linear.h":
+    SCIP_RETCODE SCIPcreateConsLinear(SCIP* scip,
+                                      SCIP_CONS** cons,
+                                      char* name,
+                                      int nvars,
+                                      SCIP_VAR** vars,
+                                      SCIP_Real* vals,
+                                      SCIP_Real lhs,
+                                      SCIP_Real rhs,
+                                      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)
+    SCIP_RETCODE SCIPaddCoefLinear(SCIP* scip,
+                                   SCIP_CONS* cons,
+                                   SCIP_VAR* var,
+                                   SCIP_Real val)
+
+    SCIP_Real SCIPgetDualsolLinear(SCIP* scip, SCIP_CONS* cons)
+    SCIP_Real SCIPgetDualfarkasLinear(SCIP* scip, SCIP_CONS* cons)
+    SCIP_RETCODE SCIPchgLhsLinear(SCIP* scip, SCIP_CONS* cons, SCIP_Real lhs)
+    SCIP_RETCODE SCIPchgRhsLinear(SCIP* scip, SCIP_CONS* cons, SCIP_Real rhs)
+    SCIP_Real SCIPgetLhsLinear(SCIP* scip, SCIP_CONS* cons)
+    SCIP_Real SCIPgetRhsLinear(SCIP* scip, SCIP_CONS* cons)
+    SCIP_RETCODE SCIPchgCoefLinear(SCIP* scip, SCIP_CONS* cons, SCIP_VAR* var, SCIP_Real newval)
+    SCIP_RETCODE SCIPdelCoefLinear(SCIP* scip, SCIP_CONS* cons, SCIP_VAR*)
+    SCIP_RETCODE SCIPaddCoefLinear(SCIP* scip, SCIP_CONS* cons, SCIP_VAR*, SCIP_Real val)
+    SCIP_Real SCIPgetActivityLinear(SCIP* scip, SCIP_CONS* cons, SCIP_SOL* sol)
+    SCIP_VAR** SCIPgetVarsLinear(SCIP* scip, SCIP_CONS* cons)
+    int SCIPgetNVarsLinear(SCIP* scip, SCIP_CONS* cons)
+    SCIP_Real* SCIPgetValsLinear(SCIP* scip, SCIP_CONS* cons)
+    SCIP_ROW* SCIPgetRowLinear(SCIP* scip, SCIP_CONS* cons)
+
+cdef extern from "scip/cons_nonlinear.h":
+    SCIP_EXPR* SCIPgetExprNonlinear(SCIP_CONS* cons)
+    SCIP_RETCODE SCIPcreateConsNonlinear(SCIP* scip,
+                                         SCIP_CONS** cons,
+                                         const char* name,
+                                         SCIP_EXPR* expr,
+                                         SCIP_Real lhs,
+                                         SCIP_Real rhs,
+                                         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_RETCODE SCIPcreateConsQuadraticNonlinear(SCIP* scip,
+                                         SCIP_CONS** cons,
+                                         const char* name,
+                                         int nlinvars,
+                                         SCIP_VAR** linvars,
+                                         SCIP_Real* lincoefs,
+                                         int nquadterms,
+                                         SCIP_VAR** quadvars1,
+                                         SCIP_VAR** quadvars2,
+                                         SCIP_Real* quadcoeffs,
+                                         SCIP_Real lhs,
+                                         SCIP_Real rhs,
+                                         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_RETCODE SCIPaddLinearVarNonlinear(SCIP* scip,
+                                           SCIP_CONS* cons,
+                                           SCIP_VAR* var,
+                                           SCIP_Real coef)
+    SCIP_RETCODE SCIPaddExprNonlinear(SCIP* scip,
+                                      SCIP_CONS* cons,
+                                      SCIP_EXPR* expr,
+                                      SCIP_Real coef)
+    SCIP_RETCODE SCIPchgLhsNonlinear(SCIP* scip, SCIP_CONS* cons, SCIP_Real lhs)
+    SCIP_RETCODE SCIPchgRhsNonlinear(SCIP* scip, SCIP_CONS* cons, SCIP_Real rhs)
+    SCIP_Real SCIPgetLhsNonlinear(SCIP_CONS* cons)
+    SCIP_Real SCIPgetRhsNonlinear(SCIP_CONS* cons)
+    SCIP_RETCODE SCIPcheckQuadraticNonlinear(SCIP* scip, SCIP_CONS* cons, SCIP_Bool* isquadratic)
+
+cdef extern from "scip/cons_sos1.h":
+    SCIP_RETCODE SCIPcreateConsSOS1(SCIP* scip,
+                                    SCIP_CONS** cons,
+                                    const char* name,
+                                    int nvars,
+                                    SCIP_VAR** vars,
+                                    SCIP_Real* weights,
+                                    SCIP_Bool initial,
+                                    SCIP_Bool separate,
+                                    SCIP_Bool enforce,
+                                    SCIP_Bool check,
+                                    SCIP_Bool propagate,
+                                    SCIP_Bool local,
+                                    SCIP_Bool dynamic,
+                                    SCIP_Bool removable,
+                                    SCIP_Bool stickingatnode)
+
+    SCIP_RETCODE SCIPaddVarSOS1(SCIP* scip,
+                                SCIP_CONS* cons,
+                                SCIP_VAR* var,
+                                SCIP_Real weight)
+
+    SCIP_RETCODE SCIPappendVarSOS1(SCIP* scip,
+                                   SCIP_CONS* cons,
+                                   SCIP_VAR* var)
+
+
+cdef extern from "scip/cons_sos2.h":
+    SCIP_RETCODE SCIPcreateConsSOS2(SCIP* scip,
+                                    SCIP_CONS** cons,
+                                    const char* name,
+                                    int nvars,
+                                    SCIP_VAR** vars,
+                                    SCIP_Real* weights,
+                                    SCIP_Bool initial,
+                                    SCIP_Bool separate,
+                                    SCIP_Bool enforce,
+                                    SCIP_Bool check,
+                                    SCIP_Bool propagate,
+                                    SCIP_Bool local,
+                                    SCIP_Bool dynamic,
+                                    SCIP_Bool removable,
+                                    SCIP_Bool stickingatnode)
+
+    SCIP_RETCODE SCIPaddVarSOS2(SCIP* scip,
+                                SCIP_CONS* cons,
+                                SCIP_VAR* var,
+                                SCIP_Real weight)
+
+    SCIP_RETCODE SCIPappendVarSOS2(SCIP* scip,
+                                   SCIP_CONS* cons,
+                                   SCIP_VAR* var)
+
+cdef extern from "scip/cons_disjunction.h":
+    SCIP_RETCODE SCIPcreateConsDisjunction(SCIP *scip,
+                                            SCIP_CONS **cons,
+                                            const char *name,
+                                            int nconss,
+                                            SCIP_CONS **conss,
+                                            SCIP_CONS *relaxcons,
+                                            SCIP_Bool initial,
+                                            SCIP_Bool enforce,
+                                            SCIP_Bool check,
+                                            SCIP_Bool local,
+                                            SCIP_Bool modifiable,
+                                            SCIP_Bool dynamic)
+
+    SCIP_RETCODE SCIPaddConsElemDisjunction(SCIP *scip,
+                                            SCIP_CONS *cons,
+                                            SCIP_CONS *addcons)
+
+cdef extern from "scip/cons_and.h":
+    SCIP_RETCODE SCIPcreateConsAnd(SCIP* scip,
+                                         SCIP_CONS** cons,
+                                         const char* name,
+                                         SCIP_VAR* resvar,
+                                         int nvars,
+                                         SCIP_VAR** vars,
+                                         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)
+
+cdef extern from "scip/cons_or.h":
+    SCIP_RETCODE SCIPcreateConsOr(SCIP* scip,
+                                         SCIP_CONS** cons,
+                                         const char* name,
+                                         SCIP_VAR* resvar,
+                                         int nvars,
+                                         SCIP_VAR** vars,
+                                         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)
+
+cdef extern from "scip/cons_xor.h":
+    SCIP_RETCODE SCIPcreateConsXor(SCIP* scip,
+                                         SCIP_CONS** cons,
+                                         const char* name,
+                                         SCIP_Bool rhs,
+                                         int nvars,
+                                         SCIP_VAR** vars,
+                                         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)
+cdef extern from "scip/scip_cons.h":
+    SCIP_RETCODE SCIPprintCons(SCIP* scip,
+                               SCIP_CONS* cons,
+                               FILE* file)
+
+cdef extern from "blockmemshell/memory.h":
+    void BMScheckEmptyMemory()
+    long long BMSgetMemoryUsed()
+
+cdef extern from "scip/scip_expr.h":
+    SCIP_RETCODE SCIPcreateExpr(SCIP* scip,
+                                SCIP_EXPR** expr,
+                                SCIP_EXPRHDLR* exprhdlr,
+                                SCIP_EXPRDATA* exprdata,
+                                int nchildren,
+                                SCIP_EXPR** children,
+                                SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                void* ownercreatedata)
+    SCIP_RETCODE SCIPcreateExprMonomial(SCIP* scip,
+                                        SCIP_EXPR** expr,
+                                        int nfactors,
+                                        SCIP_VAR** vars,
+                                        SCIP_Real* exponents,
+                                        SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                        void* ownercreatedata)
+    SCIP_RETCODE SCIPreleaseExpr(SCIP* scip, SCIP_EXPR** expr)
+
+cdef extern from "scip/pub_expr.h":
+    void SCIPexprGetQuadraticData(SCIP_EXPR* expr,
+                                  SCIP_Real* constant,
+                                  int* nlinexprs,
+                                  SCIP_EXPR*** linexprs,
+                                  SCIP_Real** lincoefs,
+                                  int* nquadexprs,
+                                  int* nbilinexprs,
+                                  SCIP_Real** eigenvalues,
+                                  SCIP_Real** eigenvectors)
+    void SCIPexprGetQuadraticQuadTerm(SCIP_EXPR* quadexpr,
+                                      int termidx,
+                                      SCIP_EXPR** expr,
+                                      SCIP_Real* lincoef,
+                                      SCIP_Real* sqrcoef,
+                                      int* nadjbilin,
+                                      int** adjbilin,
+                                      SCIP_EXPR** sqrexpr)
+    void SCIPexprGetQuadraticBilinTerm(SCIP_EXPR* expr,
+                                       int termidx,
+                                       SCIP_EXPR** expr1,
+                                       SCIP_EXPR** expr2,
+                                       SCIP_Real* coef,
+                                       int* pos2,
+                                       SCIP_EXPR** prodexpr)
+
+cdef extern from "scip/expr_var.h":
+   SCIP_VAR* SCIPgetVarExprVar(SCIP_EXPR* expr)
+   SCIP_RETCODE SCIPcreateExprVar(SCIP* scip,
+                                  SCIP_EXPR** expr,
+                                  SCIP_VAR* var,
+                                  SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                  void* ownercreatedata)
+
+cdef extern from "scip/expr_varidx.h":
+   SCIP_RETCODE SCIPcreateExprVaridx(SCIP* scip,
+                                     SCIP_EXPR** expr,
+                                     int varidx,
+                                     SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                     void* ownercreatedata)
+
+cdef extern from "scip/expr_value.h":
+   SCIP_RETCODE SCIPcreateExprValue(SCIP* scip,
+                                    SCIP_EXPR** expr,
+                                    SCIP_Real value,
+                                    SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                    void* ownercreatedata)
+
+cdef extern from "scip/expr_sum.h":
+    SCIP_RETCODE SCIPcreateExprSum(SCIP* scip,
+                                   SCIP_EXPR** expr,
+                                   int nchildren,
+                                   SCIP_EXPR** children,
+                                   SCIP_Real* coefficients,
+                                   SCIP_Real constant,
+                                   SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                   void* ownercreatedata)
+
+cdef extern from "scip/expr_abs.h":
+    SCIP_RETCODE SCIPcreateExprAbs(SCIP* scip,
+                                   SCIP_EXPR** expr,
+                                   SCIP_EXPR* child,
+                                   SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                   void* ownercreatedata)
+
+cdef extern from "scip/expr_exp.h":
+    SCIP_RETCODE SCIPcreateExprExp(SCIP* scip,
+                                   SCIP_EXPR** expr,
+                                   SCIP_EXPR* child,
+                                   SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                   void* ownercreatedata)
+
+cdef extern from "scip/expr_log.h":
+    SCIP_RETCODE SCIPcreateExprLog(SCIP* scip,
+                                   SCIP_EXPR** expr,
+                                   SCIP_EXPR* child,
+                                   SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                   void* ownercreatedata)
+
+cdef extern from "scip/expr_trig.h":
+    SCIP_RETCODE SCIPcreateExprSin(SCIP* scip,
+                                   SCIP_EXPR** expr,
+                                   SCIP_EXPR* child,
+                                   SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                   void* ownercreatedata)
+    SCIP_RETCODE SCIPcreateExprCos(SCIP* scip,
+                                   SCIP_EXPR** expr,
+                                   SCIP_EXPR* child,
+                                   SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                   void* ownercreatedata)
+
+cdef extern from "scip/expr_product.h":
+    SCIP_RETCODE SCIPcreateExprProduct(SCIP* scip,
+                                       SCIP_EXPR** expr,
+                                       int nchildren,
+                                       SCIP_EXPR** children,
+                                       SCIP_Real coefficient,
+                                       SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                       void* ownercreatedata)
+
+cdef extern from "scip/expr_pow.h":
+    SCIP_RETCODE SCIPcreateExprPow(SCIP* scip,
+                                   SCIP_EXPR** expr,
+                                   SCIP_EXPR* child,
+                                   SCIP_Real exponent,
+                                   SCIP_DECL_EXPR_OWNERCREATE((*ownercreate)),
+                                   void* ownercreatedata)
+
+cdef extern from "scip/pub_nlp.h":
+    SCIP_Real SCIPnlrowGetConstant(SCIP_NLROW* nlrow)
+    int SCIPnlrowGetNLinearVars(SCIP_NLROW* nlrow)
+    SCIP_VAR** SCIPnlrowGetLinearVars(SCIP_NLROW* nlrow)
+    SCIP_Real* SCIPnlrowGetLinearCoefs(SCIP_NLROW* nlrow)
+    SCIP_Real SCIPnlrowGetLhs(SCIP_NLROW* nlrow)
+    SCIP_Real SCIPnlrowGetRhs(SCIP_NLROW* nlrow)
+    const char* SCIPnlrowGetName(SCIP_NLROW* nlrow)
+    SCIP_Real SCIPnlrowGetDualsol(SCIP_NLROW* nlrow)
+
+cdef extern from "scip/scip_nlp.h":
+    SCIP_Bool SCIPisNLPConstructed(SCIP* scip)
+    SCIP_NLROW** SCIPgetNLPNlRows(SCIP* scip)
+    int SCIPgetNNLPNlRows(SCIP* scip)
+    SCIP_RETCODE SCIPgetNlRowSolActivity(SCIP* scip, SCIP_NLROW* nlrow, SCIP_SOL* sol, SCIP_Real* activity)
+    SCIP_RETCODE SCIPgetNlRowSolFeasibility(SCIP* scip, SCIP_NLROW* nlrow, SCIP_SOL* sol, SCIP_Real* feasibility)
+    SCIP_RETCODE SCIPgetNlRowActivityBounds(SCIP* scip, SCIP_NLROW* nlrow, SCIP_Real* minactivity, SCIP_Real* maxactivity)
+    SCIP_RETCODE SCIPprintNlRow(SCIP* scip, SCIP_NLROW* nlrow, FILE* file)
+
+
+cdef extern from "scip/cons_cardinality.h":
+    SCIP_RETCODE SCIPcreateConsCardinality(SCIP* scip,
+                                            SCIP_CONS** cons,
+                                            const char* name,
+                                            int nvars,
+                                            SCIP_VAR** vars,
+                                            int cardval,
+                                            SCIP_VAR** indvars,
+                                            SCIP_Real* weights,
+                                            SCIP_Bool initial,
+                                            SCIP_Bool separate,
+                                            SCIP_Bool enforce,
+                                            SCIP_Bool check,
+                                            SCIP_Bool propagate,
+                                            SCIP_Bool local,
+                                            SCIP_Bool dynamic,
+                                            SCIP_Bool removable,
+                                            SCIP_Bool stickingatnode)
+
+    SCIP_RETCODE SCIPaddVarCardinality(SCIP* scip,
+                                       SCIP_CONS* cons,
+                                       SCIP_VAR* var,
+                                       SCIP_VAR* indvar,
+                                       SCIP_Real weight)
+
+    SCIP_RETCODE SCIPappendVarCardinality(SCIP* scip,
+                                          SCIP_CONS* cons,
+                                          SCIP_VAR* var,
+                                          SCIP_VAR* indvar)
+
+cdef extern from "scip/cons_indicator.h":
+    SCIP_RETCODE SCIPcreateConsIndicator(SCIP* scip,
+                                         SCIP_CONS** cons,
+                                         const char* name,
+                                         SCIP_VAR* binvar,
+                                         int nvars,
+                                         SCIP_VAR** vars,
+                                         SCIP_Real* vals,
+                                         SCIP_Real rhs,
+                                         SCIP_Bool initial,
+                                         SCIP_Bool separate,
+                                         SCIP_Bool enforce,
+                                         SCIP_Bool check,
+                                         SCIP_Bool propagate,
+                                         SCIP_Bool local,
+                                         SCIP_Bool dynamic,
+                                         SCIP_Bool removable,
+                                         SCIP_Bool stickingatnode)
+
+    SCIP_RETCODE SCIPaddVarIndicator(SCIP* scip,
+                                     SCIP_CONS* cons,
+                                     SCIP_VAR* var,
+                                     SCIP_Real val)
+
+    SCIP_VAR* SCIPgetSlackVarIndicator(SCIP_CONS* cons)
+
+cdef extern from "scip/cons_countsols.h":
+    SCIP_RETCODE SCIPcount(SCIP* scip)
+    SCIP_RETCODE SCIPsetParamsCountsols(SCIP* scip)
+    SCIP_Longint SCIPgetNCountedSols(SCIP* scip, SCIP_Bool* valid)
+
+cdef extern from "scip/paramset.h":
+
+    ctypedef struct SCIP_PARAM:
+        pass
+
+    const char* SCIPparamGetName(SCIP_PARAM* param)
+    SCIP_PARAMTYPE SCIPparamGetType(SCIP_PARAM* param)
+    SCIP_Bool SCIPparamGetBool(SCIP_PARAM* param)
+    int SCIPparamGetInt(SCIP_PARAM* param)
+    SCIP_Longint SCIPparamGetLongint(SCIP_PARAM* param)
+    SCIP_Real SCIPparamGetReal(SCIP_PARAM* param)
+    char SCIPparamGetChar(SCIP_PARAM* param)
+    char* SCIPparamGetString(SCIP_PARAM* param)
+
+cdef extern from "scip/pub_lp.h":
+    # Row Methods
+    const char* SCIProwGetName(SCIP_ROW* row)
+    SCIP_Real SCIProwGetLhs(SCIP_ROW* row)
+    SCIP_Real SCIProwGetRhs(SCIP_ROW* row)
+    SCIP_Real SCIProwGetConstant(SCIP_ROW* row)
+    int SCIProwGetLPPos(SCIP_ROW* row)
+    SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW* row)
+    SCIP_Bool SCIProwIsIntegral(SCIP_ROW* row)
+    SCIP_Bool SCIProwIsLocal(SCIP_ROW* row)
+    SCIP_Bool SCIProwIsModifiable(SCIP_ROW* row)
+    SCIP_Bool SCIProwIsRemovable(SCIP_ROW* row)
+    SCIP_Bool SCIProwIsInGlobalCutpool(SCIP_ROW* row)
+    int SCIProwGetNNonz(SCIP_ROW* row)
+    int SCIProwGetNLPNonz(SCIP_ROW* row)
+    SCIP_COL** SCIProwGetCols(SCIP_ROW* row)
+    SCIP_Real* SCIProwGetVals(SCIP_ROW* row)
+    SCIP_Real SCIProwGetNorm(SCIP_ROW* row)
+    SCIP_Real SCIProwGetDualsol(SCIP_ROW* row)
+    SCIP_Real SCIProwGetParallelism(SCIP_ROW* row1, SCIP_ROW* row2, const char orthofunc)
+    int SCIProwGetAge(SCIP_ROW* row)
+    SCIP_Bool SCIProwIsRemovable(SCIP_ROW* row)
+    SCIP_ROWORIGINTYPE SCIProwGetOrigintype(SCIP_ROW* row)
+    SCIP_CONS* SCIProwGetOriginCons(SCIP_ROW* row)
+
+    # Column Methods
+    int SCIPcolGetLPPos(SCIP_COL* col)
+    SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL* col)
+    SCIP_Bool SCIPcolIsIntegral(SCIP_COL* col)
+    SCIP_VAR* SCIPcolGetVar(SCIP_COL* col)
+    SCIP_Real SCIPcolGetPrimsol(SCIP_COL* col)
+    SCIP_Real SCIPcolGetLb(SCIP_COL* col)
+    SCIP_Real SCIPcolGetUb(SCIP_COL* col)
+    int SCIPcolGetNLPNonz(SCIP_COL* col)
+    int SCIPcolGetNNonz(SCIP_COL* col)
+    SCIP_ROW** SCIPcolGetRows(SCIP_COL* col)
+    SCIP_Real* SCIPcolGetVals(SCIP_COL* col)
+    int SCIPcolGetIndex(SCIP_COL* col)
+    SCIP_Real SCIPcolGetObj(SCIP_COL *col)
+
+cdef extern from "scip/scip_tree.h":
+    SCIP_RETCODE SCIPgetOpenNodesData(SCIP* scip, SCIP_NODE*** leaves, SCIP_NODE*** children, SCIP_NODE*** siblings, int* nleaves, int* nchildren, int* nsiblings)
+    SCIP_Longint SCIPgetNLeaves(SCIP* scip)
+    SCIP_Longint SCIPgetNChildren(SCIP* scip)
+    SCIP_Longint SCIPgetNSiblings(SCIP* scip)
+    SCIP_NODE* SCIPgetBestChild(SCIP* scip)
+    SCIP_NODE* SCIPgetBestSibling(SCIP* scip)
+    SCIP_NODE* SCIPgetBestLeaf(SCIP* scip)
+    SCIP_NODE* SCIPgetBestNode(SCIP* scip)
+    SCIP_NODE* SCIPgetBestboundNode(SCIP* scip)
+    SCIP_RETCODE SCIPrepropagateNode(SCIP* scip, SCIP_NODE* node)
+
+cdef extern from "scip/scip_var.h":
+    SCIP_RETCODE SCIPchgVarBranchPriority(SCIP* scip, SCIP_VAR* var, int branchpriority)
+
+    SCIP_RETCODE SCIPgetNegatedVar(SCIP* scip, SCIP_VAR* var, SCIP_VAR** negvar)
+
+cdef extern from "tpi/tpi.h":
+    int SCIPtpiGetNumThreads()
+
+cdef class Expr:
+    cdef public terms
+
+cdef class Event:
+    cdef SCIP_EVENT* event
+    # can be used to store problem data
+    cdef public object data
+    @staticmethod
+    cdef create(SCIP_EVENT* scip_event)
+
+cdef class Column:
+    cdef SCIP_COL* scip_col
+    # can be used to store problem data
+    cdef public object data
+
+    @staticmethod
+    cdef create(SCIP_COL* scipcol)
+
+cdef class Row:
+    cdef SCIP_ROW* scip_row
+    # can be used to store problem data
+    cdef public object data
+
+    @staticmethod
+    cdef create(SCIP_ROW* sciprow)
+
+cdef class NLRow:
+    cdef SCIP_NLROW* scip_nlrow
+    # can be used to store problem data
+    cdef public object data
+
+    @staticmethod
+    cdef create(SCIP_NLROW* scipnlrow)
+
+cdef class Solution:
+    cdef SCIP_SOL* sol
+    cdef SCIP* scip
+    # can be used to store problem data
+    cdef public object data
+
+    @staticmethod
+    cdef create(SCIP* scip, SCIP_SOL* scip_sol)
+
+cdef class DomainChanges:
+    cdef SCIP_DOMCHG* scip_domchg
+
+    @staticmethod
+    cdef create(SCIP_DOMCHG* scip_domchg)
+
+cdef class BoundChange:
+    cdef SCIP_BOUNDCHG* scip_boundchg
+
+    @staticmethod
+    cdef create(SCIP_BOUNDCHG* scip_boundchg)
+
+cdef class Node:
+    cdef SCIP_NODE* scip_node
+    # can be used to store problem data
+    cdef public object data
+
+    @staticmethod
+    cdef create(SCIP_NODE* scipnode)
+
+cdef class Variable(Expr):
+    cdef SCIP_VAR* scip_var
+    # can be used to store problem data
+    cdef public object data
+
+    @staticmethod
+    cdef create(SCIP_VAR* scipvar)
+
+cdef class Constraint:
+    cdef SCIP_CONS* scip_cons
+    # can be used to store problem data
+    cdef public object data
+
+    @staticmethod
+    cdef create(SCIP_CONS* scipcons)
+
+cdef class Model:
+    cdef SCIP* _scip
+    cdef SCIP_Bool* _valid
+    # store best solution to get the solution values easier
+    cdef Solution _bestSol
+    # can be used to store problem data
+    cdef public object data
+    # make Model weak referentiable
+    cdef object __weakref__
+    # flag to indicate whether the SCIP should be freed. It will not be freed if an empty Model was created to wrap a
+    # C-API SCIP instance.
+    cdef SCIP_Bool _freescip
+    # map to store python variables
+    cdef _modelvars
+
+    @staticmethod
+    cdef create(SCIP* scip)
diff --git a/src/pyscipopt/scip.pxi b/src/pyscipopt/scip.pxi
new file mode 100644
index 0000000..d12cd5c
--- /dev/null
+++ b/src/pyscipopt/scip.pxi
@@ -0,0 +1,5453 @@
+##@file scip.pxi
+#@brief holding functions in python that reference the SCIP public functions included in scip.pxd
+import weakref
+from os.path import abspath
+from os.path import splitext
+import os
+import sys
+import warnings
+import locale
+
+cimport cython
+from cpython cimport Py_INCREF, Py_DECREF
+from cpython.pycapsule cimport PyCapsule_New, PyCapsule_IsValid, PyCapsule_GetPointer
+from libc.stdlib cimport malloc, free
+from libc.stdio cimport fdopen, fclose
+from posix.stdio cimport fileno
+
+from collections.abc import Iterable
+from itertools import repeat
+
+include "expr.pxi"
+include "lp.pxi"
+include "benders.pxi"
+include "benderscut.pxi"
+include "branchrule.pxi"
+include "conshdlr.pxi"
+include "cutsel.pxi"
+include "event.pxi"
+include "heuristic.pxi"
+include "presol.pxi"
+include "pricer.pxi"
+include "propagator.pxi"
+include "sepa.pxi"
+include "reader.pxi"
+include "relax.pxi"
+include "nodesel.pxi"
+
+# recommended SCIP version; major version is required
+MAJOR = 9
+MINOR = 0
+PATCH = 0
+
+# for external user functions use def; for functions used only inside the interface (starting with _) use cdef
+# todo: check whether this is currently done like this
+
+if sys.version_info >= (3, 0):
+    str_conversion = lambda x:bytes(x,'utf-8')
+else:
+    str_conversion = lambda x:x
+
+_SCIP_BOUNDTYPE_TO_STRING = {SCIP_BOUNDTYPE_UPPER: '<=',
+                             SCIP_BOUNDTYPE_LOWER: '>='}
+
+# Mapping the SCIP_RESULT enum to a python class
+# This is required to return SCIP_RESULT in the python code
+# In __init__.py this is imported as SCIP_RESULT to keep the
+# original naming scheme using capital letters
+cdef class PY_SCIP_RESULT:
+    DIDNOTRUN   = SCIP_DIDNOTRUN
+    DELAYED     = SCIP_DELAYED
+    DIDNOTFIND  = SCIP_DIDNOTFIND
+    FEASIBLE    = SCIP_FEASIBLE
+    INFEASIBLE  = SCIP_INFEASIBLE
+    UNBOUNDED   = SCIP_UNBOUNDED
+    CUTOFF      = SCIP_CUTOFF
+    SEPARATED   = SCIP_SEPARATED
+    NEWROUND    = SCIP_NEWROUND
+    REDUCEDDOM  = SCIP_REDUCEDDOM
+    CONSADDED   = SCIP_CONSADDED
+    CONSCHANGED = SCIP_CONSCHANGED
+    BRANCHED    = SCIP_BRANCHED
+    SOLVELP     = SCIP_SOLVELP
+    FOUNDSOL    = SCIP_FOUNDSOL
+    SUSPENDED   = SCIP_SUSPENDED
+    SUCCESS     = SCIP_SUCCESS
+
+cdef class PY_SCIP_PARAMSETTING:
+    DEFAULT     = SCIP_PARAMSETTING_DEFAULT
+    AGGRESSIVE  = SCIP_PARAMSETTING_AGGRESSIVE
+    FAST        = SCIP_PARAMSETTING_FAST
+    OFF         = SCIP_PARAMSETTING_OFF
+
+cdef class PY_SCIP_PARAMEMPHASIS:
+    DEFAULT      = SCIP_PARAMEMPHASIS_DEFAULT
+    CPSOLVER     = SCIP_PARAMEMPHASIS_CPSOLVER
+    EASYCIP      = SCIP_PARAMEMPHASIS_EASYCIP
+    FEASIBILITY  = SCIP_PARAMEMPHASIS_FEASIBILITY
+    HARDLP       = SCIP_PARAMEMPHASIS_HARDLP
+    OPTIMALITY   = SCIP_PARAMEMPHASIS_OPTIMALITY
+    COUNTER      = SCIP_PARAMEMPHASIS_COUNTER
+    PHASEFEAS    = SCIP_PARAMEMPHASIS_PHASEFEAS
+    PHASEIMPROVE = SCIP_PARAMEMPHASIS_PHASEIMPROVE
+    PHASEPROOF   = SCIP_PARAMEMPHASIS_PHASEPROOF
+    NUMERICS     = SCIP_PARAMEMPHASIS_NUMERICS
+    BENCHMARK    = SCIP_PARAMEMPHASIS_BENCHMARK
+
+cdef class PY_SCIP_STATUS:
+    UNKNOWN        = SCIP_STATUS_UNKNOWN
+    USERINTERRUPT  = SCIP_STATUS_USERINTERRUPT
+    NODELIMIT      = SCIP_STATUS_NODELIMIT
+    TOTALNODELIMIT = SCIP_STATUS_TOTALNODELIMIT
+    STALLNODELIMIT = SCIP_STATUS_STALLNODELIMIT
+    TIMELIMIT      = SCIP_STATUS_TIMELIMIT
+    MEMLIMIT       = SCIP_STATUS_MEMLIMIT
+    GAPLIMIT       = SCIP_STATUS_GAPLIMIT
+    SOLLIMIT       = SCIP_STATUS_SOLLIMIT
+    BESTSOLLIMIT   = SCIP_STATUS_BESTSOLLIMIT
+    RESTARTLIMIT   = SCIP_STATUS_RESTARTLIMIT
+    PRIMALLIMIT    = SCIP_STATUS_PRIMALLIMIT
+    DUALLIMIT      = SCIP_STATUS_DUALLIMIT
+    OPTIMAL        = SCIP_STATUS_OPTIMAL
+    INFEASIBLE     = SCIP_STATUS_INFEASIBLE
+    UNBOUNDED      = SCIP_STATUS_UNBOUNDED
+    INFORUNBD      = SCIP_STATUS_INFORUNBD
+
+StageNames = {}
+
+cdef class PY_SCIP_STAGE:
+    INIT         = SCIP_STAGE_INIT
+    PROBLEM      = SCIP_STAGE_PROBLEM
+    TRANSFORMING = SCIP_STAGE_TRANSFORMING
+    TRANSFORMED  = SCIP_STAGE_TRANSFORMED
+    INITPRESOLVE = SCIP_STAGE_INITPRESOLVE
+    PRESOLVING   = SCIP_STAGE_PRESOLVING
+    EXITPRESOLVE = SCIP_STAGE_EXITPRESOLVE
+    PRESOLVED    = SCIP_STAGE_PRESOLVED
+    INITSOLVE    = SCIP_STAGE_INITSOLVE
+    SOLVING      = SCIP_STAGE_SOLVING
+    SOLVED       = SCIP_STAGE_SOLVED
+    EXITSOLVE    = SCIP_STAGE_EXITSOLVE
+    FREETRANS    = SCIP_STAGE_FREETRANS
+    FREE         = SCIP_STAGE_FREE
+
+cdef class PY_SCIP_NODETYPE:
+    FOCUSNODE   = SCIP_NODETYPE_FOCUSNODE
+    PROBINGNODE = SCIP_NODETYPE_PROBINGNODE
+    SIBLING     = SCIP_NODETYPE_SIBLING
+    CHILD       = SCIP_NODETYPE_CHILD
+    LEAF        = SCIP_NODETYPE_LEAF
+    DEADEND     = SCIP_NODETYPE_DEADEND
+    JUNCTION    = SCIP_NODETYPE_JUNCTION
+    PSEUDOFORK  = SCIP_NODETYPE_PSEUDOFORK
+    FORK        = SCIP_NODETYPE_FORK
+    SUBROOT     = SCIP_NODETYPE_SUBROOT
+    REFOCUSNODE = SCIP_NODETYPE_REFOCUSNODE
+
+
+cdef class PY_SCIP_PROPTIMING:
+    BEFORELP     = SCIP_PROPTIMING_BEFORELP
+    DURINGLPLOOP = SCIP_PROPTIMING_DURINGLPLOOP
+    AFTERLPLOOP  = SCIP_PROPTIMING_AFTERLPLOOP
+    AFTERLPNODE  = SCIP_PROPTIMING_AFTERLPNODE
+
+cdef class PY_SCIP_PRESOLTIMING:
+    NONE       = SCIP_PRESOLTIMING_NONE
+    FAST       = SCIP_PRESOLTIMING_FAST
+    MEDIUM     = SCIP_PRESOLTIMING_MEDIUM
+    EXHAUSTIVE = SCIP_PRESOLTIMING_EXHAUSTIVE
+
+cdef class PY_SCIP_HEURTIMING:
+    BEFORENODE        = SCIP_HEURTIMING_BEFORENODE
+    DURINGLPLOOP      = SCIP_HEURTIMING_DURINGLPLOOP
+    AFTERLPLOOP       = SCIP_HEURTIMING_AFTERLPLOOP
+    AFTERLPNODE       = SCIP_HEURTIMING_AFTERLPNODE
+    AFTERPSEUDONODE   = SCIP_HEURTIMING_AFTERPSEUDONODE
+    AFTERLPPLUNGE     = SCIP_HEURTIMING_AFTERLPPLUNGE
+    AFTERPSEUDOPLUNGE = SCIP_HEURTIMING_AFTERPSEUDOPLUNGE
+    DURINGPRICINGLOOP = SCIP_HEURTIMING_DURINGPRICINGLOOP
+    BEFOREPRESOL      = SCIP_HEURTIMING_BEFOREPRESOL
+    DURINGPRESOLLOOP  = SCIP_HEURTIMING_DURINGPRESOLLOOP
+    AFTERPROPLOOP     = SCIP_HEURTIMING_AFTERPROPLOOP
+
+EventNames = {}
+
+cdef class PY_SCIP_EVENTTYPE:
+    DISABLED        = SCIP_EVENTTYPE_DISABLED
+    VARADDED        = SCIP_EVENTTYPE_VARADDED
+    VARDELETED      = SCIP_EVENTTYPE_VARDELETED
+    VARFIXED        = SCIP_EVENTTYPE_VARFIXED
+    VARUNLOCKED     = SCIP_EVENTTYPE_VARUNLOCKED
+    OBJCHANGED      = SCIP_EVENTTYPE_OBJCHANGED
+    GLBCHANGED      = SCIP_EVENTTYPE_GLBCHANGED
+    GUBCHANGED      = SCIP_EVENTTYPE_GUBCHANGED
+    LBTIGHTENED     = SCIP_EVENTTYPE_LBTIGHTENED
+    LBRELAXED       = SCIP_EVENTTYPE_LBRELAXED
+    UBTIGHTENED     = SCIP_EVENTTYPE_UBTIGHTENED
+    UBRELAXED       = SCIP_EVENTTYPE_UBRELAXED
+    GHOLEADDED      = SCIP_EVENTTYPE_GHOLEADDED
+    GHOLEREMOVED    = SCIP_EVENTTYPE_GHOLEREMOVED
+    LHOLEADDED      = SCIP_EVENTTYPE_LHOLEADDED
+    LHOLEREMOVED    = SCIP_EVENTTYPE_LHOLEREMOVED
+    IMPLADDED       = SCIP_EVENTTYPE_IMPLADDED
+    PRESOLVEROUND   = SCIP_EVENTTYPE_PRESOLVEROUND
+    NODEFOCUSED     = SCIP_EVENTTYPE_NODEFOCUSED
+    NODEFEASIBLE    = SCIP_EVENTTYPE_NODEFEASIBLE
+    NODEINFEASIBLE  = SCIP_EVENTTYPE_NODEINFEASIBLE
+    NODEBRANCHED    = SCIP_EVENTTYPE_NODEBRANCHED
+    NODEDELETE      = SCIP_EVENTTYPE_NODEDELETE
+    FIRSTLPSOLVED   = SCIP_EVENTTYPE_FIRSTLPSOLVED
+    LPSOLVED        = SCIP_EVENTTYPE_LPSOLVED
+    LPEVENT         = SCIP_EVENTTYPE_LPEVENT
+    POORSOLFOUND    = SCIP_EVENTTYPE_POORSOLFOUND
+    BESTSOLFOUND    = SCIP_EVENTTYPE_BESTSOLFOUND
+    ROWADDEDSEPA    = SCIP_EVENTTYPE_ROWADDEDSEPA
+    ROWDELETEDSEPA  = SCIP_EVENTTYPE_ROWDELETEDSEPA
+    ROWADDEDLP      = SCIP_EVENTTYPE_ROWADDEDLP
+    ROWDELETEDLP    = SCIP_EVENTTYPE_ROWDELETEDLP
+    ROWCOEFCHANGED  = SCIP_EVENTTYPE_ROWCOEFCHANGED
+    ROWCONSTCHANGED = SCIP_EVENTTYPE_ROWCONSTCHANGED
+    ROWSIDECHANGED  = SCIP_EVENTTYPE_ROWSIDECHANGED
+    SYNC            = SCIP_EVENTTYPE_SYNC
+    GBDCHANGED      = SCIP_EVENTTYPE_GBDCHANGED
+    LBCHANGED       = SCIP_EVENTTYPE_LBCHANGED
+    UBCHANGED       = SCIP_EVENTTYPE_UBCHANGED
+    BOUNDTIGHTENED  = SCIP_EVENTTYPE_BOUNDTIGHTENED
+    BOUNDRELAXED    = SCIP_EVENTTYPE_BOUNDRELAXED
+    BOUNDCHANGED    = SCIP_EVENTTYPE_BOUNDCHANGED
+    GHOLECHANGED    = SCIP_EVENTTYPE_GHOLECHANGED
+    LHOLECHANGED    = SCIP_EVENTTYPE_LHOLECHANGED
+    HOLECHANGED     = SCIP_EVENTTYPE_HOLECHANGED
+    DOMCHANGED      = SCIP_EVENTTYPE_DOMCHANGED
+    VARCHANGED      = SCIP_EVENTTYPE_VARCHANGED
+    VAREVENT        = SCIP_EVENTTYPE_VAREVENT
+    NODESOLVED      = SCIP_EVENTTYPE_NODESOLVED
+    NODEEVENT       = SCIP_EVENTTYPE_NODEEVENT
+    SOLFOUND        = SCIP_EVENTTYPE_SOLFOUND
+    SOLEVENT        = SCIP_EVENTTYPE_SOLEVENT
+    ROWCHANGED      = SCIP_EVENTTYPE_ROWCHANGED
+    ROWEVENT        = SCIP_EVENTTYPE_ROWEVENT
+
+
+cdef class PY_SCIP_LPSOLSTAT:
+    NOTSOLVED    = SCIP_LPSOLSTAT_NOTSOLVED
+    OPTIMAL      = SCIP_LPSOLSTAT_OPTIMAL
+    INFEASIBLE   = SCIP_LPSOLSTAT_INFEASIBLE
+    UNBOUNDEDRAY = SCIP_LPSOLSTAT_UNBOUNDEDRAY
+    OBJLIMIT     = SCIP_LPSOLSTAT_OBJLIMIT
+    ITERLIMIT    = SCIP_LPSOLSTAT_ITERLIMIT
+    TIMELIMIT    = SCIP_LPSOLSTAT_TIMELIMIT
+    ERROR        = SCIP_LPSOLSTAT_ERROR
+
+cdef class PY_SCIP_BRANCHDIR:
+    DOWNWARDS = SCIP_BRANCHDIR_DOWNWARDS
+    UPWARDS   = SCIP_BRANCHDIR_UPWARDS
+    FIXED     = SCIP_BRANCHDIR_FIXED
+    AUTO      = SCIP_BRANCHDIR_AUTO
+
+cdef class PY_SCIP_BENDERSENFOTYPE:
+    LP     = SCIP_BENDERSENFOTYPE_LP
+    RELAX  = SCIP_BENDERSENFOTYPE_RELAX
+    PSEUDO = SCIP_BENDERSENFOTYPE_PSEUDO
+    CHECK  = SCIP_BENDERSENFOTYPE_CHECK
+
+cdef class PY_SCIP_ROWORIGINTYPE:
+    UNSPEC = SCIP_ROWORIGINTYPE_UNSPEC
+    CONS   = SCIP_ROWORIGINTYPE_CONS
+    SEPA   = SCIP_ROWORIGINTYPE_SEPA
+    REOPT  = SCIP_ROWORIGINTYPE_REOPT
+
+def PY_SCIP_CALL(SCIP_RETCODE rc):
+    if rc == SCIP_OKAY:
+        pass
+    elif rc == SCIP_ERROR:
+        raise Exception('SCIP: unspecified error!')
+    elif rc == SCIP_NOMEMORY:
+        raise MemoryError('SCIP: insufficient memory error!')
+    elif rc == SCIP_READERROR:
+        raise IOError('SCIP: read error!')
+    elif rc == SCIP_WRITEERROR:
+        raise IOError('SCIP: write error!')
+    elif rc == SCIP_NOFILE:
+        raise IOError('SCIP: file not found error!')
+    elif rc == SCIP_FILECREATEERROR:
+        raise IOError('SCIP: cannot create file!')
+    elif rc == SCIP_LPERROR:
+        raise Exception('SCIP: error in LP solver!')
+    elif rc == SCIP_NOPROBLEM:
+        raise Exception('SCIP: no problem exists!')
+    elif rc == SCIP_INVALIDCALL:
+        raise Exception('SCIP: method cannot be called at this time'
+                            + ' in solution process!')
+    elif rc == SCIP_INVALIDDATA:
+        raise Exception('SCIP: error in input data!')
+    elif rc == SCIP_INVALIDRESULT:
+        raise Exception('SCIP: method returned an invalid result code!')
+    elif rc == SCIP_PLUGINNOTFOUND:
+        raise Exception('SCIP: a required plugin was not found !')
+    elif rc == SCIP_PARAMETERUNKNOWN:
+        raise KeyError('SCIP: the parameter with the given name was not found!')
+    elif rc == SCIP_PARAMETERWRONGTYPE:
+        raise LookupError('SCIP: the parameter is not of the expected type!')
+    elif rc == SCIP_PARAMETERWRONGVAL:
+        raise ValueError('SCIP: the value is invalid for the given parameter!')
+    elif rc == SCIP_KEYALREADYEXISTING:
+        raise KeyError('SCIP: the given key is already existing in table!')
+    elif rc == SCIP_MAXDEPTHLEVEL:
+        raise Exception('SCIP: maximal branching depth level exceeded!')
+    else:
+        raise Exception('SCIP: unknown return code!')
+
+cdef class Event:
+    """Base class holding a pointer to corresponding SCIP_EVENT"""
+
+    @staticmethod
+    cdef create(SCIP_EVENT* scip_event):
+        if scip_event == NULL:
+            raise Warning("cannot create Event with SCIP_EVENT* == NULL")
+        event = Event()
+        event.event = scip_event
+        return event
+
+    def getType(self):
+        """gets type of event"""
+        return SCIPeventGetType(self.event)
+
+    def getName(self):
+        """gets name of event"""
+        if not EventNames:
+            self._getEventNames()
+        return EventNames[self.getType()]
+
+    def _getEventNames(self):
+        """gets event names"""
+        for name in dir(PY_SCIP_EVENTTYPE):
+            attr = getattr(PY_SCIP_EVENTTYPE, name)
+            if isinstance(attr, int):
+                EventNames[attr] = name
+        
+    def __repr__(self):
+        return str(self.getType())
+
+    def __str__(self):
+        return self.getName()
+
+    def getNewBound(self):
+        """gets new bound for a bound change event"""
+        return SCIPeventGetNewbound(self.event)
+
+    def getOldBound(self):
+        """gets old bound for a bound change event"""
+        return SCIPeventGetOldbound(self.event)
+
+    def getVar(self):
+        """gets variable for a variable event (var added, var deleted, var fixed, objective value or domain change, domain hole added or removed)"""
+        cdef SCIP_VAR* var = SCIPeventGetVar(self.event)
+        return Variable.create(var)
+
+    def getNode(self):
+        """gets node for a node or LP event"""
+        cdef SCIP_NODE* node = SCIPeventGetNode(self.event)
+        return Node.create(node)
+
+    def getRow(self):
+        """gets row for a row event"""
+        cdef SCIP_ROW* row = SCIPeventGetRow(self.event)
+        return Row.create(row)
+
+    def __hash__(self):
+        return hash(self.event)
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__
+                and self.event == (other).event)
+
+cdef class Column:
+    """Base class holding a pointer to corresponding SCIP_COL"""
+
+    @staticmethod
+    cdef create(SCIP_COL* scipcol):
+        if scipcol == NULL:
+            raise Warning("cannot create Column with SCIP_COL* == NULL")
+        col = Column()
+        col.scip_col = scipcol
+        return col
+
+    def getLPPos(self):
+        """gets position of column in current LP, or -1 if it is not in LP"""
+        return SCIPcolGetLPPos(self.scip_col)
+
+    def getBasisStatus(self):
+        """gets the basis status of a column in the LP solution, Note: returns basis status `zero` for columns not in the current SCIP LP"""
+        cdef SCIP_BASESTAT stat = SCIPcolGetBasisStatus(self.scip_col)
+        if stat == SCIP_BASESTAT_LOWER:
+            return "lower"
+        elif stat == SCIP_BASESTAT_BASIC:
+            return "basic"
+        elif stat == SCIP_BASESTAT_UPPER:
+            return "upper"
+        elif stat == SCIP_BASESTAT_ZERO:
+            return "zero"
+        else:
+            raise Exception('SCIP returned unknown base status!')
+
+    def isIntegral(self):
+        """returns whether the associated variable is of integral type (binary, integer, implicit integer)"""
+        return SCIPcolIsIntegral(self.scip_col)
+
+    def getVar(self):
+        """gets variable this column represents"""
+        cdef SCIP_VAR* var = SCIPcolGetVar(self.scip_col)
+        return Variable.create(var)
+
+    def getPrimsol(self):
+        """gets the primal LP solution of a column"""
+        return SCIPcolGetPrimsol(self.scip_col)
+
+    def getLb(self):
+        """gets lower bound of column"""
+        return SCIPcolGetLb(self.scip_col)
+
+    def getUb(self):
+        """gets upper bound of column"""
+        return SCIPcolGetUb(self.scip_col)
+
+    def getObjCoeff(self):
+        """gets objective value coefficient of a column"""
+        return SCIPcolGetObj(self.scip_col)
+
+    def __hash__(self):
+        return hash(self.scip_col)
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__
+                and self.scip_col == (other).scip_col)
+
+cdef class Row:
+    """Base class holding a pointer to corresponding SCIP_ROW"""
+
+    @staticmethod
+    cdef create(SCIP_ROW* sciprow):
+        if sciprow == NULL:
+            raise Warning("cannot create Row with SCIP_ROW* == NULL")
+        row = Row()
+        row.scip_row = sciprow
+        return row
+
+    property name:
+        def __get__(self):
+            cname = bytes( SCIProwGetName(self.scip_row) )
+            return cname.decode('utf-8')
+
+    def getLhs(self):
+        """returns the left hand side of row"""
+        return SCIProwGetLhs(self.scip_row)
+
+    def getRhs(self):
+        """returns the right hand side of row"""
+        return SCIProwGetRhs(self.scip_row)
+
+    def getConstant(self):
+        """gets constant shift of row"""
+        return SCIProwGetConstant(self.scip_row)
+
+    def getLPPos(self):
+        """gets position of row in current LP, or -1 if it is not in LP"""
+        return SCIProwGetLPPos(self.scip_row)
+
+    def getBasisStatus(self):
+        """gets the basis status of a row in the LP solution, Note: returns basis status `basic` for rows not in the current SCIP LP"""
+        cdef SCIP_BASESTAT stat = SCIProwGetBasisStatus(self.scip_row)
+        if stat == SCIP_BASESTAT_LOWER:
+            return "lower"
+        elif stat == SCIP_BASESTAT_BASIC:
+            return "basic"
+        elif stat == SCIP_BASESTAT_UPPER:
+            return "upper"
+        elif stat == SCIP_BASESTAT_ZERO:
+            # this shouldn't happen!
+            raise Exception('SCIP returned base status zero for a row!')
+        else:
+            raise Exception('SCIP returned unknown base status!')
+
+    def isIntegral(self):
+        """returns TRUE iff the activity of the row (without the row's constant) is always integral in a feasible solution """
+        return SCIProwIsIntegral(self.scip_row)
+
+    def isLocal(self):
+        """returns TRUE iff the row is only valid locally """
+        return SCIProwIsLocal(self.scip_row)
+
+    def isModifiable(self):
+        """returns TRUE iff row is modifiable during node processing (subject to column generation) """
+        return SCIProwIsModifiable(self.scip_row)
+
+    def isRemovable(self):
+        """returns TRUE iff row is removable from the LP (due to aging or cleanup)"""
+        return SCIProwIsRemovable(self.scip_row)
+
+    def isInGlobalCutpool(self):
+        """return TRUE iff row is a member of the global cut pool"""
+        return SCIProwIsInGlobalCutpool(self.scip_row)
+
+    def getOrigintype(self):
+        """returns type of origin that created the row"""
+        return SCIProwGetOrigintype(self.scip_row)
+
+    def getConsOriginConshdlrtype(self):
+        """returns type of constraint handler that created the row"""
+        cdef SCIP_CONS* scip_con = SCIProwGetOriginCons(self.scip_row)
+        return bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(scip_con))).decode('UTF-8')
+
+    def getNNonz(self):
+        """get number of nonzero entries in row vector"""
+        return SCIProwGetNNonz(self.scip_row)
+
+    def getNLPNonz(self):
+        """get number of nonzero entries in row vector that correspond to columns currently in the SCIP LP"""
+        return SCIProwGetNLPNonz(self.scip_row)
+
+    def getCols(self):
+        """gets list with columns of nonzero entries"""
+        cdef SCIP_COL** cols = SCIProwGetCols(self.scip_row)
+        return [Column.create(cols[i]) for i in range(self.getNNonz())]
+
+    def getVals(self):
+        """gets list with coefficients of nonzero entries"""
+        cdef SCIP_Real* vals = SCIProwGetVals(self.scip_row)
+        return [vals[i] for i in range(self.getNNonz())]
+
+    def getNorm(self):
+        """gets Euclidean norm of row vector """
+        return SCIProwGetNorm(self.scip_row)
+
+    def __hash__(self):
+        return hash(self.scip_row)
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__
+                and self.scip_row == (other).scip_row)
+
+cdef class NLRow:
+    """Base class holding a pointer to corresponding SCIP_NLROW"""
+
+    @staticmethod
+    cdef create(SCIP_NLROW* scipnlrow):
+        if scipnlrow == NULL:
+            raise Warning("cannot create NLRow with SCIP_NLROW* == NULL")
+        nlrow = NLRow()
+        nlrow.scip_nlrow = scipnlrow
+        return nlrow
+
+    property name:
+        def __get__(self):
+            cname = bytes( SCIPnlrowGetName(self.scip_nlrow) )
+            return cname.decode('utf-8')
+
+    def getConstant(self):
+        """returns the constant of a nonlinear row"""
+        return SCIPnlrowGetConstant(self.scip_nlrow)
+
+    def getLinearTerms(self):
+        """returns a list of tuples (var, coef) representing the linear part of a nonlinear row"""
+        cdef SCIP_VAR** linvars = SCIPnlrowGetLinearVars(self.scip_nlrow)
+        cdef SCIP_Real* lincoefs = SCIPnlrowGetLinearCoefs(self.scip_nlrow)
+        cdef int nlinvars = SCIPnlrowGetNLinearVars(self.scip_nlrow)
+        return [(Variable.create(linvars[i]), lincoefs[i]) for i in range(nlinvars)]
+
+    def getLhs(self):
+        """returns the left hand side of a nonlinear row"""
+        return SCIPnlrowGetLhs(self.scip_nlrow)
+
+    def getRhs(self):
+        """returns the right hand side of a nonlinear row"""
+        return SCIPnlrowGetRhs(self.scip_nlrow)
+
+    def getDualsol(self):
+        """gets the dual NLP solution of a nonlinear row"""
+        return SCIPnlrowGetDualsol(self.scip_nlrow)
+
+    def __hash__(self):
+        return hash(self.scip_nlrow)
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__
+                and self.scip_nlrow == (other).scip_nlrow)
+
+cdef class Solution:
+    """Base class holding a pointer to corresponding SCIP_SOL"""
+
+    # We are raising an error here to avoid creating a solution without an associated model. See Issue #625
+    def __init__(self, raise_error = False):
+        if not raise_error:
+            raise ValueError("To create a solution you should use the createSol method of the Model class.")
+
+    @staticmethod
+    cdef create(SCIP* scip, SCIP_SOL* scip_sol):
+        if scip == NULL:
+            raise Warning("cannot create Solution with SCIP* == NULL")
+        sol = Solution(True)
+        sol.sol = scip_sol
+        sol.scip = scip
+        return sol
+
+    def __getitem__(self, Expr expr):
+        # fast track for Variable
+        if isinstance(expr, Variable):
+            self._checkStage("SCIPgetSolVal")
+            var =  expr
+            return SCIPgetSolVal(self.scip, self.sol, var.scip_var)
+        return sum(self._evaluate(term)*coeff for term, coeff in expr.terms.items() if coeff != 0)
+    
+    def _evaluate(self, term):
+        self._checkStage("SCIPgetSolVal")
+        result = 1
+        for var in term.vartuple:
+            result *= SCIPgetSolVal(self.scip, self.sol, ( var).scip_var)
+        return result
+
+    def __setitem__(self, Variable var, value):
+        PY_SCIP_CALL(SCIPsetSolVal(self.scip, self.sol, var.scip_var, value))
+
+    def __repr__(self):
+        cdef SCIP_VAR* scip_var
+
+        vals = {}
+        self._checkStage("SCIPgetSolVal")
+        for i in range(SCIPgetNOrigVars(self.scip)):
+            scip_var = SCIPgetOrigVars(self.scip)[i]
+
+            # extract name
+            cname = bytes(SCIPvarGetName(scip_var))
+            name = cname.decode('utf-8')
+
+            vals[name] = SCIPgetSolVal(self.scip, self.sol, scip_var)
+        return str(vals)
+    
+    def _checkStage(self, method):
+        if method in ["SCIPgetSolVal", "getSolObjVal"]:
+            if self.sol == NULL and SCIPgetStage(self.scip) != SCIP_STAGE_SOLVING:
+                raise Warning(f"{method} can only be called with a valid solution or in stage SOLVING (current stage: {SCIPgetStage(self.scip)})")
+
+
+cdef class BoundChange:
+    """Bound change."""
+
+    @staticmethod
+    cdef create(SCIP_BOUNDCHG* scip_boundchg):
+        if scip_boundchg == NULL:
+            raise Warning("cannot create BoundChange with SCIP_BOUNDCHG* == NULL")
+        boundchg = BoundChange()
+        boundchg.scip_boundchg = scip_boundchg
+        return boundchg
+
+    def getNewBound(self):
+        """Returns the new value of the bound in the bound change."""
+        return SCIPboundchgGetNewbound(self.scip_boundchg)
+
+    def getVar(self):
+        """Returns the variable of the bound change."""
+        return Variable.create(SCIPboundchgGetVar(self.scip_boundchg))
+
+    def getBoundchgtype(self):
+        """Returns the bound change type of the bound change."""
+        return SCIPboundchgGetBoundchgtype(self.scip_boundchg)
+
+    def getBoundtype(self):
+        """Returns the bound type of the bound change."""
+        return SCIPboundchgGetBoundtype(self.scip_boundchg)
+
+    def isRedundant(self):
+        """Returns whether the bound change is redundant due to a more global bound that is at least as strong."""
+        return SCIPboundchgIsRedundant(self.scip_boundchg)
+
+    def __repr__(self):
+        return "{} {} {}".format(self.getVar(),
+                                 _SCIP_BOUNDTYPE_TO_STRING[self.getBoundtype()],
+                                 self.getNewBound())
+
+cdef class DomainChanges:
+    """Set of domain changes."""
+
+    @staticmethod
+    cdef create(SCIP_DOMCHG* scip_domchg):
+        if scip_domchg == NULL:
+            raise Warning("cannot create DomainChanges with SCIP_DOMCHG* == NULL")
+        domchg = DomainChanges()
+        domchg.scip_domchg = scip_domchg
+        return domchg
+
+    def getBoundchgs(self):
+        """Returns the bound changes in the domain change."""
+        nboundchgs = SCIPdomchgGetNBoundchgs(self.scip_domchg)
+        return [BoundChange.create(SCIPdomchgGetBoundchg(self.scip_domchg, i))
+                for i in range(nboundchgs)]
+
+cdef class Node:
+    """Base class holding a pointer to corresponding SCIP_NODE"""
+
+    @staticmethod
+    cdef create(SCIP_NODE* scipnode):
+        if scipnode == NULL:
+            return None
+        node = Node()
+        node.scip_node = scipnode
+        return node
+
+    def getParent(self):
+        """Retrieve parent node (or None if the node has no parent node)."""
+        return Node.create(SCIPnodeGetParent(self.scip_node))
+
+    def getNumber(self):
+        """Retrieve number of node."""
+        return SCIPnodeGetNumber(self.scip_node)
+
+    def getDepth(self):
+        """Retrieve depth of node."""
+        return SCIPnodeGetDepth(self.scip_node)
+
+    def getType(self):
+        """Retrieve type of node."""
+        return SCIPnodeGetType(self.scip_node)
+
+    def getLowerbound(self):
+        """Retrieve lower bound of node."""
+        return SCIPnodeGetLowerbound(self.scip_node)
+
+    def getEstimate(self):
+        """Retrieve the estimated value of the best feasible solution in subtree of the node"""
+        return SCIPnodeGetEstimate(self.scip_node)
+
+    def getAddedConss(self):
+        """Retrieve all constraints added at this node."""
+        cdef int addedconsssize = SCIPnodeGetNAddedConss(self.scip_node)
+        if addedconsssize == 0:
+            return []
+        cdef SCIP_CONS** addedconss =  malloc(addedconsssize * sizeof(SCIP_CONS*))
+        cdef int nconss
+        SCIPnodeGetAddedConss(self.scip_node, addedconss, &nconss, addedconsssize)
+        assert nconss == addedconsssize
+        constraints = [Constraint.create(addedconss[i]) for i in range(nconss)]
+        free(addedconss)
+        return constraints
+
+    def getNAddedConss(self):
+        """Retrieve number of added constraints at this node"""
+        return SCIPnodeGetNAddedConss(self.scip_node)
+
+    def isActive(self):
+        """Is the node in the path to the current node?"""
+        return SCIPnodeIsActive(self.scip_node)
+
+    def isPropagatedAgain(self):
+        """Is the node marked to be propagated again?"""
+        return SCIPnodeIsPropagatedAgain(self.scip_node)
+
+    def getNParentBranchings(self):
+        """Retrieve the number of variable branchings that were performed in the parent node to create this node."""
+        cdef SCIP_VAR* dummy_branchvars
+        cdef SCIP_Real dummy_branchbounds
+        cdef SCIP_BOUNDTYPE dummy_boundtypes
+        cdef int nbranchvars
+        # This is a hack: the SCIP interface has no function to directly get the
+        # number of parent branchings, i.e., SCIPnodeGetNParentBranchings() does
+        # not exist.
+        SCIPnodeGetParentBranchings(self.scip_node, &dummy_branchvars,
+                                    &dummy_branchbounds, &dummy_boundtypes,
+                                    &nbranchvars, 0)
+        return nbranchvars
+
+    def getParentBranchings(self):
+        """Retrieve the set of variable branchings that were performed in the parent node to create this node."""
+        cdef int nbranchvars = self.getNParentBranchings()
+        if nbranchvars == 0:
+            return None
+
+        cdef SCIP_VAR** branchvars =  malloc(nbranchvars * sizeof(SCIP_VAR*))
+        cdef SCIP_Real* branchbounds =  malloc(nbranchvars * sizeof(SCIP_Real))
+        cdef SCIP_BOUNDTYPE* boundtypes =  malloc(nbranchvars * sizeof(SCIP_BOUNDTYPE))
+
+        SCIPnodeGetParentBranchings(self.scip_node, branchvars, branchbounds,
+                                    boundtypes, &nbranchvars, nbranchvars)
+
+        py_variables = [Variable.create(branchvars[i]) for i in range(nbranchvars)]
+        py_branchbounds = [branchbounds[i] for i in range(nbranchvars)]
+        py_boundtypes = [boundtypes[i] for i in range(nbranchvars)]
+
+        free(boundtypes)
+        free(branchbounds)
+        free(branchvars)
+        return py_variables, py_branchbounds, py_boundtypes
+
+    def getNDomchg(self):
+        """Retrieve the number of bound changes due to branching, constraint propagation, and propagation."""
+        cdef int nbranchings
+        cdef int nconsprop
+        cdef int nprop
+        SCIPnodeGetNDomchg(self.scip_node, &nbranchings, &nconsprop, &nprop)
+        return nbranchings, nconsprop, nprop
+
+    def getDomchg(self):
+        """Retrieve domain changes for this node."""
+        cdef SCIP_DOMCHG* domchg = SCIPnodeGetDomchg(self.scip_node)
+        if domchg == NULL:
+            return None
+        return DomainChanges.create(domchg)
+
+    def __hash__(self):
+        return hash(self.scip_node)
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__
+                and self.scip_node == (other).scip_node)
+
+cdef class Variable(Expr):
+    """Is a linear expression and has SCIP_VAR*"""
+
+    @staticmethod
+    cdef create(SCIP_VAR* scipvar):
+        if scipvar == NULL:
+            raise Warning("cannot create Variable with SCIP_VAR* == NULL")
+        var = Variable()
+        var.scip_var = scipvar
+        Expr.__init__(var, {Term(var) : 1.0})
+        return var
+
+    property name:
+        def __get__(self):
+            cname = bytes( SCIPvarGetName(self.scip_var) )
+            return cname.decode('utf-8')
+
+    def ptr(self):
+        """ """
+        return (self.scip_var)
+
+    def __repr__(self):
+        return self.name
+
+    def vtype(self):
+        """Retrieve the variables type (BINARY, INTEGER, IMPLINT or CONTINUOUS)"""
+        vartype = SCIPvarGetType(self.scip_var)
+        if vartype == SCIP_VARTYPE_BINARY:
+            return "BINARY"
+        elif vartype == SCIP_VARTYPE_INTEGER:
+            return "INTEGER"
+        elif vartype == SCIP_VARTYPE_CONTINUOUS:
+            return "CONTINUOUS"
+        elif vartype == SCIP_VARTYPE_IMPLINT:
+            return "IMPLINT"
+
+    def isOriginal(self):
+        """Retrieve whether the variable belongs to the original problem"""
+        return SCIPvarIsOriginal(self.scip_var)
+
+    def isInLP(self):
+        """Retrieve whether the variable is a COLUMN variable that is member of the current LP"""
+        return SCIPvarIsInLP(self.scip_var)
+
+
+    def getIndex(self):
+        """Retrieve the unique index of the variable."""
+        return SCIPvarGetIndex(self.scip_var)
+
+    def getCol(self):
+        """Retrieve column of COLUMN variable"""
+        cdef SCIP_COL* scip_col
+        scip_col = SCIPvarGetCol(self.scip_var)
+        return Column.create(scip_col)
+
+    def getLbOriginal(self):
+        """Retrieve original lower bound of variable"""
+        return SCIPvarGetLbOriginal(self.scip_var)
+
+    def getUbOriginal(self):
+        """Retrieve original upper bound of variable"""
+        return SCIPvarGetUbOriginal(self.scip_var)
+
+    def getLbGlobal(self):
+        """Retrieve global lower bound of variable"""
+        return SCIPvarGetLbGlobal(self.scip_var)
+
+    def getUbGlobal(self):
+        """Retrieve global upper bound of variable"""
+        return SCIPvarGetUbGlobal(self.scip_var)
+
+    def getLbLocal(self):
+        """Retrieve current lower bound of variable"""
+        return SCIPvarGetLbLocal(self.scip_var)
+
+    def getUbLocal(self):
+        """Retrieve current upper bound of variable"""
+        return SCIPvarGetUbLocal(self.scip_var)
+
+    def getObj(self):
+        """Retrieve current objective value of variable"""
+        return SCIPvarGetObj(self.scip_var)
+
+    def getLPSol(self):
+        """Retrieve the current LP solution value of variable"""
+        return SCIPvarGetLPSol(self.scip_var)
+
+cdef class Constraint:
+    """Base class holding a pointer to corresponding SCIP_CONS"""
+
+    @staticmethod
+    cdef create(SCIP_CONS* scipcons):
+        if scipcons == NULL:
+            raise Warning("cannot create Constraint with SCIP_CONS* == NULL")
+        cons = Constraint()
+        cons.scip_cons = scipcons
+        return cons
+
+    property name:
+        def __get__(self):
+            cname = bytes( SCIPconsGetName(self.scip_cons) )
+            return cname.decode('utf-8')
+
+    def __repr__(self):
+        return self.name
+
+    def isOriginal(self):
+        """Retrieve whether the constraint belongs to the original problem"""
+        return SCIPconsIsOriginal(self.scip_cons)
+
+    def isInitial(self):
+        """Retrieve True if the relaxation of the constraint should be in the initial LP"""
+        return SCIPconsIsInitial(self.scip_cons)
+
+    def isSeparated(self):
+        """Retrieve True if constraint should be separated during LP processing"""
+        return SCIPconsIsSeparated(self.scip_cons)
+
+    def isEnforced(self):
+        """Retrieve True if constraint should be enforced during node processing"""
+        return SCIPconsIsEnforced(self.scip_cons)
+
+    def isChecked(self):
+        """Retrieve True if constraint should be checked for feasibility"""
+        return SCIPconsIsChecked(self.scip_cons)
+
+    def isPropagated(self):
+        """Retrieve True if constraint should be propagated during node processing"""
+        return SCIPconsIsPropagated(self.scip_cons)
+
+    def isLocal(self):
+        """Retrieve True if constraint is only locally valid or not added to any (sub)problem"""
+        return SCIPconsIsLocal(self.scip_cons)
+
+    def isModifiable(self):
+        """Retrieve True if constraint is modifiable (subject to column generation)"""
+        return SCIPconsIsModifiable(self.scip_cons)
+
+    def isDynamic(self):
+        """Retrieve True if constraint is subject to aging"""
+        return SCIPconsIsDynamic(self.scip_cons)
+
+    def isRemovable(self):
+        """Retrieve True if constraint's relaxation should be removed from the LP due to aging or cleanup"""
+        return SCIPconsIsRemovable(self.scip_cons)
+
+    def isStickingAtNode(self):
+        """Retrieve True if constraint is only locally valid or not added to any (sub)problem"""
+        return SCIPconsIsStickingAtNode(self.scip_cons)
+
+    def isActive(self):
+        """returns True iff constraint is active in the current node"""
+        return SCIPconsIsActive(self.scip_cons)
+
+    def isLinear(self):
+        """Retrieve True if constraint is linear"""
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8')
+        return constype == 'linear'
+
+    def isNonlinear(self):
+        """Retrieve True if constraint is nonlinear"""
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8')
+        return constype == 'nonlinear'
+
+    def getConshdlrName(self):
+        """Return the constraint handler's name"""
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(self.scip_cons))).decode('UTF-8')
+        return constype
+
+    def __hash__(self):
+        return hash(self.scip_cons)
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__
+                and self.scip_cons == (other).scip_cons)
+
+
+cdef void relayMessage(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *msg) noexcept:
+    sys.stdout.write(msg.decode('UTF-8'))
+
+cdef void relayErrorMessage(void *messagehdlr, FILE *file, const char *msg) noexcept:
+    sys.stderr.write(msg.decode('UTF-8'))
+
+# - remove create(), includeDefaultPlugins(), createProbBasic() methods
+# - replace free() by "destructor"
+# - interface SCIPfreeProb()
+##
+#@anchor Model
+##
+cdef class Model:
+    """Main class holding a pointer to SCIP for managing most interactions"""
+
+    def __init__(self, problemName='model', defaultPlugins=True, Model sourceModel=None, origcopy=False, globalcopy=True, enablepricing=False, createscip=True, threadsafe=False):
+        """
+        :param problemName: name of the problem (default 'model')
+        :param defaultPlugins: use default plugins? (default True)
+        :param sourceModel: create a copy of the given Model instance (default None)
+        :param origcopy: whether to call copy or copyOrig (default False)
+        :param globalcopy: whether to create a global or a local copy (default True)
+        :param enablepricing: whether to enable pricing in copy (default False)
+        :param createscip: initialize the Model object and creates a SCIP instance
+        :param threadsafe: False if data can be safely shared between the source and target problem
+        """
+        if self.version() < MAJOR:
+            raise Exception("linked SCIP is not compatible to this version of PySCIPOpt - use at least version", MAJOR)
+        if self.version() < MAJOR + MINOR/10.0 + PATCH/100.0:
+            warnings.warn("linked SCIP {} is not recommended for this version of PySCIPOpt - use version {}.{}.{}".format(self.version(), MAJOR, MINOR, PATCH))
+
+        self._freescip = True
+        self._modelvars = {}
+
+        if not createscip:
+            # if no SCIP instance should be created, then an empty Model object is created.
+            self._scip = NULL
+            self._bestSol = None
+            self._freescip = False
+        elif sourceModel is None:
+            PY_SCIP_CALL(SCIPcreate(&self._scip))
+            self._bestSol = None
+            if defaultPlugins:
+                self.includeDefaultPlugins()
+            self.createProbBasic(problemName)
+        else:
+            PY_SCIP_CALL(SCIPcreate(&self._scip))
+            self._bestSol =  sourceModel._bestSol
+            n = str_conversion(problemName)
+            if origcopy:
+                PY_SCIP_CALL(SCIPcopyOrig(sourceModel._scip, self._scip, NULL, NULL, n, enablepricing, threadsafe, True, self._valid))
+            else:
+                PY_SCIP_CALL(SCIPcopy(sourceModel._scip, self._scip, NULL, NULL, n, globalcopy, enablepricing, threadsafe, True, self._valid))
+
+    def __dealloc__(self):
+        # call C function directly, because we can no longer call this object's methods, according to
+        # http://docs.cython.org/src/reference/extension_types.html#finalization-dealloc
+        if self._scip is not NULL and self._freescip and PY_SCIP_CALL:
+           PY_SCIP_CALL( SCIPfree(&self._scip) )
+
+    def __hash__(self):
+        return hash(self._scip)
+
+    def __eq__(self, other):
+        return (self.__class__ == other.__class__
+                and self._scip == (other)._scip)
+
+    @staticmethod
+    cdef create(SCIP* scip):
+        """Creates a model and appropriately assigns the scip and bestsol parameters
+        """
+        if scip == NULL:
+            raise Warning("cannot create Model with SCIP* == NULL")
+        model = Model(createscip=False)
+        model._scip = scip
+        model._bestSol = Solution.create(scip, SCIPgetBestSol(scip))
+        return model
+
+    @property
+    def _freescip(self):
+        """Return whether the underlying Scip pointer gets deallocted when the current
+        object is deleted.
+        """
+        return self._freescip
+
+    @_freescip.setter
+    def _freescip(self, val):
+        """Set whether the underlying Scip pointer gets deallocted when the current
+        object is deleted.
+        """
+        self._freescip = val
+
+    @cython.always_allow_keywords(True)
+    @staticmethod
+    def from_ptr(capsule, take_ownership):
+        """Create a Model from a given pointer.
+
+        :param cpasule: The PyCapsule containing the SCIP pointer under the name "scip".
+        :param take_ownership: Whether the newly created Model assumes ownership of the
+        underlying Scip pointer (see `_freescip`).
+        """
+        if not PyCapsule_IsValid(capsule, "scip"):
+            raise ValueError("The given capsule does not contain a valid scip pointer")
+        model = Model.create(PyCapsule_GetPointer(capsule, "scip"))
+        model._freescip = take_ownership
+        return model
+
+    @cython.always_allow_keywords(True)
+    def to_ptr(self, give_ownership):
+        """Return the underlying Scip pointer to the current Model.
+
+        :param give_ownership: Whether the current Model gives away ownership of the
+        underlying Scip pointer (see `_freescip`).
+        :return capsule: The underlying pointer to the current Model, wrapped in a
+        PyCapsule under the name "scip".
+        """
+        capsule = PyCapsule_New(self._scip, "scip", NULL)
+        if give_ownership:
+            self._freescip = False
+        return capsule
+
+    def includeDefaultPlugins(self):
+        """Includes all default plug-ins into SCIP"""
+        PY_SCIP_CALL(SCIPincludeDefaultPlugins(self._scip))
+
+    def createProbBasic(self, problemName='model'):
+        """Create new problem instance with given name
+
+        :param problemName: name of model or problem (Default value = 'model')
+
+        """
+        n = str_conversion(problemName)
+        PY_SCIP_CALL(SCIPcreateProbBasic(self._scip, n))
+
+    def freeProb(self):
+        """Frees problem and solution process data"""
+        PY_SCIP_CALL(SCIPfreeProb(self._scip))
+
+    def freeTransform(self):
+        """Frees all solution process data including presolving and transformed problem, only original problem is kept"""
+        self._modelvars = {
+            var: value
+            for var, value in self._modelvars.items()
+            if value.isOriginal()
+        }
+        PY_SCIP_CALL(SCIPfreeTransform(self._scip))
+
+    def version(self):
+        """Retrieve SCIP version"""
+        return SCIPversion()
+
+    def printVersion(self):
+        """Print version, copyright information and compile mode"""
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        SCIPprintVersion(self._scip, NULL)
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def printExternalCodeVersions(self):
+        """Print external code versions, e.g. symmetry, non-linear solver, lp solver"""
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        SCIPprintExternalCodes(self._scip, NULL)
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def getProbName(self):
+        """Retrieve problem name"""
+        return bytes(SCIPgetProbName(self._scip)).decode('UTF-8')
+
+    def getTotalTime(self):
+        """Retrieve the current total SCIP time in seconds, i.e. the total time since the SCIP instance has been created"""
+        return SCIPgetTotalTime(self._scip)
+
+    def getSolvingTime(self):
+        """Retrieve the current solving time in seconds"""
+        return SCIPgetSolvingTime(self._scip)
+
+    def getReadingTime(self):
+        """Retrieve the current reading time in seconds"""
+        return SCIPgetReadingTime(self._scip)
+
+    def getPresolvingTime(self):
+        """Retrieve the curernt presolving time in seconds"""
+        return SCIPgetPresolvingTime(self._scip)
+
+    def getNLPIterations(self):
+        """Retrieve the total number of LP iterations so far."""
+        return SCIPgetNLPIterations(self._scip)
+
+    def getNNodes(self):
+        """gets number of processed nodes in current run, including the focus node."""
+        return SCIPgetNNodes(self._scip)
+
+    def getNTotalNodes(self):
+        """gets number of processed nodes in all runs, including the focus node."""
+        return SCIPgetNTotalNodes(self._scip)
+
+    def getNFeasibleLeaves(self):
+        """Retrieve number of leaf nodes processed with feasible relaxation solution."""
+        return SCIPgetNFeasibleLeaves(self._scip)
+
+    def getNInfeasibleLeaves(self):
+        """gets number of infeasible leaf nodes processed."""
+        return SCIPgetNInfeasibleLeaves(self._scip)
+
+    def getNLeaves(self):
+        """gets number of leaves in the tree."""
+        return SCIPgetNLeaves(self._scip)
+
+    def getNChildren(self):
+        """gets number of children of focus node."""
+        return SCIPgetNChildren(self._scip)
+
+    def getNSiblings(self):
+        """gets number of siblings of focus node."""
+        return SCIPgetNSiblings(self._scip)
+
+    def getCurrentNode(self):
+        """Retrieve current node."""
+        return Node.create(SCIPgetCurrentNode(self._scip))
+
+    def getGap(self):
+        """Retrieve the gap, i.e. |(primalbound - dualbound)/min(|primalbound|,|dualbound|)|."""
+        return SCIPgetGap(self._scip)
+
+    def getDepth(self):
+        """Retrieve the depth of the current node"""
+        return SCIPgetDepth(self._scip)
+
+    def infinity(self):
+        """Retrieve SCIP's infinity value"""
+        return SCIPinfinity(self._scip)
+
+    def epsilon(self):
+        """Retrieve epsilon for e.g. equality checks"""
+        return SCIPepsilon(self._scip)
+
+    def feastol(self):
+        """Retrieve feasibility tolerance"""
+        return SCIPfeastol(self._scip)
+
+    def feasFrac(self, value):
+        """returns fractional part of value, i.e. x - floor(x) in feasible tolerance: x - floor(x+feastol)"""
+        return SCIPfeasFrac(self._scip, value)
+
+    def frac(self, value):
+        """returns fractional part of value, i.e. x - floor(x) in epsilon tolerance: x - floor(x+eps)"""
+        return SCIPfrac(self._scip, value)
+
+    def isZero(self, value):
+        """returns whether abs(value) < eps"""
+        return SCIPisZero(self._scip, value)
+
+    def isFeasZero(self, value):
+        """returns whether abs(value) < feastol"""
+        return SCIPisFeasZero(self._scip, value)
+
+    def isInfinity(self, value):
+        """returns whether value is SCIP's infinity"""
+        return SCIPisInfinity(self._scip, value)
+
+    def isFeasNegative(self, value):
+        """returns whether value < -feastol"""
+        return SCIPisFeasNegative(self._scip, value)
+
+    def isFeasIntegral(self, value):
+        """returns whether value is integral within the LP feasibility bounds"""
+        return SCIPisFeasIntegral(self._scip, value)
+
+    def isEQ(self, val1, val2):
+        """checks, if values are in range of epsilon"""
+        return SCIPisEQ(self._scip, val1, val2)
+
+    def isFeasEQ(self, val1, val2):
+        """checks, if relative difference of values is in range of feasibility tolerance"""
+        return SCIPisFeasEQ(self._scip, val1, val2)
+
+    def isLE(self, val1, val2):
+        """returns whether val1 <= val2 + eps"""
+        return SCIPisLE(self._scip, val1, val2)
+
+    def isLT(self, val1, val2):
+        """returns whether val1 < val2 - eps"""
+        return SCIPisLT(self._scip, val1, val2)
+
+    def isGE(self, val1, val2):
+        """returns whether val1 >= val2 - eps"""
+        return SCIPisGE(self._scip, val1, val2)
+
+    def isGT(self, val1, val2):
+        """returns whether val1 > val2 + eps"""
+        return SCIPisGT(self._scip, val1, val2)
+
+    def getCondition(self, exact=False):
+        """Get the current LP's condition number
+
+        :param exact: whether to get an estimate or the exact value (Default value = False)
+
+        """
+        cdef SCIP_LPI* lpi
+        PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi))
+        cdef SCIP_Real quality = 0
+        if exact:
+            PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_EXACTCONDITION, &quality))
+        else:
+            PY_SCIP_CALL(SCIPlpiGetRealSolQuality(lpi, SCIP_LPSOLQUALITY_ESTIMCONDITION, &quality))
+
+        return quality
+
+    def enableReoptimization(self, enable=True):
+        """include specific heuristics and branching rules for reoptimization"""
+        PY_SCIP_CALL(SCIPenableReoptimization(self._scip, enable))
+
+    def lpiGetIterations(self):
+        """Get the iteration count of the last solved LP"""
+        cdef SCIP_LPI* lpi
+        PY_SCIP_CALL(SCIPgetLPI(self._scip, &lpi))
+        cdef int iters = 0
+        PY_SCIP_CALL(SCIPlpiGetIterations(lpi, &iters))
+        return iters
+
+    # Objective function
+
+    def setMinimize(self):
+        """Set the objective sense to minimization."""
+        PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MINIMIZE))
+
+    def setMaximize(self):
+        """Set the objective sense to maximization."""
+        PY_SCIP_CALL(SCIPsetObjsense(self._scip, SCIP_OBJSENSE_MAXIMIZE))
+
+    def setObjlimit(self, objlimit):
+        """Set a limit on the objective function.
+        Only solutions with objective value better than this limit are accepted.
+
+        :param objlimit: limit on the objective function
+
+        """
+        PY_SCIP_CALL(SCIPsetObjlimit(self._scip, objlimit))
+
+    def getObjlimit(self):
+        """returns current limit on objective function."""
+        return SCIPgetObjlimit(self._scip)
+
+    def setObjective(self, expr, sense = 'minimize', clear = 'true'):
+        """Establish the objective function as a linear expression.
+
+        :param expr: the objective function SCIP Expr, or constant value
+        :param sense: the objective sense (Default value = 'minimize')
+        :param clear: set all other variables objective coefficient to zero (Default value = 'true')
+
+        """
+ 
+        cdef SCIP_VAR** _vars
+        cdef int _nvars
+
+        # turn the constant value into an Expr instance for further processing
+        if not isinstance(expr, Expr):
+            assert(_is_number(expr)), "given coefficients are neither Expr or number but %s" % expr.__class__.__name__
+            expr = Expr() + expr
+
+        if expr.degree() > 1:
+            raise ValueError("SCIP does not support nonlinear objective functions. Consider using set_nonlinear_objective in the pyscipopt.recipe.nonlinear")
+        
+        if clear:
+            # clear existing objective function
+            self.addObjoffset(-self.getObjoffset())
+            _vars = SCIPgetOrigVars(self._scip)
+            _nvars = SCIPgetNOrigVars(self._scip)
+            for i in range(_nvars):
+                PY_SCIP_CALL(SCIPchgVarObj(self._scip, _vars[i], 0.0))
+
+        if expr[CONST] != 0.0:
+            self.addObjoffset(expr[CONST])
+
+        for term, coef in expr.terms.items():
+            # avoid CONST term of Expr
+            if term != CONST:
+                assert len(term) == 1
+                var = term[0]
+                PY_SCIP_CALL(SCIPchgVarObj(self._scip, var.scip_var, coef))
+
+        if sense == "minimize":
+            self.setMinimize()
+        elif sense == "maximize":
+            self.setMaximize()
+        else:
+            raise Warning("unrecognized optimization sense: %s" % sense)
+
+    def getObjective(self):
+        """Retrieve objective function as Expr"""
+        variables = self.getVars()
+        objective = Expr()
+        for var in variables:
+            coeff = var.getObj()
+            if coeff != 0:
+                objective += coeff * var
+        objective.normalize()
+        return objective
+
+    def addObjoffset(self, offset, solutions = False):
+        """Add constant offset to objective
+
+        :param offset: offset to add
+        :param solutions: add offset also to existing solutions (Default value = False)
+
+        """
+        if solutions:
+            PY_SCIP_CALL(SCIPaddObjoffset(self._scip, offset))
+        else:
+            PY_SCIP_CALL(SCIPaddOrigObjoffset(self._scip, offset))
+
+    def getObjoffset(self, original = True):
+        """Retrieve constant objective offset
+
+        :param original: offset of original or transformed problem (Default value = True)
+
+        """
+        if original:
+            return SCIPgetOrigObjoffset(self._scip)
+        else:
+            return SCIPgetTransObjoffset(self._scip)
+
+    def setObjIntegral(self):
+        """informs SCIP that the objective value is always integral in every feasible solution
+        Note: This function should be used to inform SCIP that the objective function is integral, helping to improve the
+        performance. This is useful when using column generation. If no column generation (pricing) is used, SCIP
+        automatically detects whether the objective function is integral or can be scaled to be integral. However, in
+        any case, the user has to make sure that no variable is added during the solving process that destroys this
+        property.
+        """
+        PY_SCIP_CALL(SCIPsetObjIntegral(self._scip))
+
+    def getLocalEstimate(self, original = False):
+        """gets estimate of best primal solution w.r.t. original or transformed problem contained in current subtree
+
+        :param original: estimate of original or transformed problem (Default value = False)
+        """
+        if original:
+            return SCIPgetLocalOrigEstimate(self._scip)
+        else:
+            return SCIPgetLocalTransEstimate(self._scip)
+
+    # Setting parameters
+    def setPresolve(self, setting):
+        """Set presolving parameter settings.
+
+        :param setting: the parameter settings (SCIP_PARAMSETTING)
+
+        """
+        PY_SCIP_CALL(SCIPsetPresolving(self._scip, setting, True))
+
+    def setProbName(self, name):
+        """Set problem name"""
+        n = str_conversion(name)
+        PY_SCIP_CALL(SCIPsetProbName(self._scip, n))
+
+    def setSeparating(self, setting):
+        """Set separating parameter settings.
+
+        :param setting: the parameter settings (SCIP_PARAMSETTING)
+
+        """
+        PY_SCIP_CALL(SCIPsetSeparating(self._scip, setting, True))
+
+    def setHeuristics(self, setting):
+        """Set heuristics parameter settings.
+
+        :param setting: the parameter setting (SCIP_PARAMSETTING)
+
+        """
+        PY_SCIP_CALL(SCIPsetHeuristics(self._scip, setting, True))
+
+    def disablePropagation(self, onlyroot=False):
+        """Disables propagation in SCIP to avoid modifying the original problem during transformation.
+
+        :param onlyroot: use propagation when root processing is finished (Default value = False)
+
+        """
+        self.setIntParam("propagating/maxroundsroot", 0)
+        if not onlyroot:
+            self.setIntParam("propagating/maxrounds", 0)
+
+    def writeProblem(self, filename='model.cip', trans=False, genericnames=False, verbose=True):
+        """Write current model/problem to a file.
+
+        :param filename: the name of the file to be used (Default value = 'model.cip'). Should have an extension corresponding to one of the readable file formats, described in https://www.scipopt.org/doc/html/group__FILEREADERS.php.
+        :param trans: indicates whether the transformed problem is written to file (Default value = False)
+        :param genericnames: indicates whether the problem should be written with generic variable and constraint names (Default value = False)
+        :param verbose: indicates whether a success message should be printed
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        str_absfile = abspath(filename)
+        absfile = str_conversion(str_absfile)
+        fn, ext = splitext(absfile)
+
+        if len(ext) == 0:
+            ext = str_conversion('.cip')
+        fn = fn + ext
+        ext = ext[1:]
+
+        if trans:
+            PY_SCIP_CALL(SCIPwriteTransProblem(self._scip, fn, ext, genericnames))
+        else:
+            PY_SCIP_CALL(SCIPwriteOrigProblem(self._scip, fn, ext, genericnames))
+        
+        if verbose:
+            print('wrote problem to file ' + str_absfile)
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    # Variable Functions
+
+    def addVar(self, name='', vtype='C', lb=0.0, ub=None, obj=0.0, pricedVar=False, pricedVarScore=1.0):
+        """Create a new variable. Default variable is non-negative and continuous.
+
+        :param name: name of the variable, generic if empty (Default value = '')
+        :param vtype: type of the variable: 'C' continuous, 'I' integer, 'B' binary, and 'M' implicit integer
+        (see https://www.scipopt.org/doc/html/FAQ.php#implicitinteger) (Default value = 'C')
+        :param lb: lower bound of the variable, use None for -infinity (Default value = 0.0)
+        :param ub: upper bound of the variable, use None for +infinity (Default value = None)
+        :param obj: objective value of variable (Default value = 0.0)
+        :param pricedVar: is the variable a pricing candidate? (Default value = False)
+        :param pricedVarScore: score of variable in case it is priced, the higher the better (Default value = 1.0)
+
+        """
+        cdef SCIP_VAR* scip_var
+
+        # replace empty name with generic one
+        if name == '':
+            name = 'x'+str(SCIPgetNVars(self._scip)+1)
+        cname = str_conversion(name)
+
+        # replace None with corresponding infinity
+        if lb is None:
+            lb = -SCIPinfinity(self._scip)
+        if ub is None:
+            ub = SCIPinfinity(self._scip)
+
+        vtype = vtype.upper()
+        if vtype in ['C', 'CONTINUOUS']:
+            PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_CONTINUOUS))
+        elif vtype in ['B', 'BINARY']:
+            if ub > 1.0:
+                ub = 1.0
+            if lb < 0.0:
+                lb = 0.0
+            PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_BINARY))
+        elif vtype in ['I', 'INTEGER']:
+            PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_INTEGER))
+        elif vtype in ['M', 'IMPLINT']:
+            PY_SCIP_CALL(SCIPcreateVarBasic(self._scip, &scip_var, cname, lb, ub, obj, SCIP_VARTYPE_IMPLINT))
+        else:
+            raise Warning("unrecognized variable type")
+
+        if pricedVar:
+            PY_SCIP_CALL(SCIPaddPricedVar(self._scip, scip_var, pricedVarScore))
+        else:
+            PY_SCIP_CALL(SCIPaddVar(self._scip, scip_var))
+
+        pyVar = Variable.create(scip_var)
+
+        # store variable in the model to avoid creating new python variable objects in getVars()
+        assert not pyVar.ptr() in self._modelvars
+        self._modelvars[pyVar.ptr()] = pyVar
+
+        #setting the variable data
+        SCIPvarSetData(scip_var, pyVar)
+        PY_SCIP_CALL(SCIPreleaseVar(self._scip, &scip_var))
+        return pyVar
+
+    def getTransformedVar(self, Variable var):
+        """Retrieve the transformed variable.
+
+        :param Variable var: original variable to get the transformed of
+
+        """
+        cdef SCIP_VAR* _tvar
+        PY_SCIP_CALL(SCIPgetTransformedVar(self._scip, var.scip_var, &_tvar))
+
+        return Variable.create(_tvar)
+
+    def addVarLocks(self, Variable var, nlocksdown, nlocksup):
+        """adds given values to lock numbers of variable for rounding
+
+        :param Variable var: variable to adjust the locks for
+        :param nlocksdown: new number of down locks
+        :param nlocksup: new number of up locks
+
+        """
+        PY_SCIP_CALL(SCIPaddVarLocks(self._scip, var.scip_var, nlocksdown, nlocksup))
+
+    def fixVar(self, Variable var, val):
+        """Fixes the variable var to the value val if possible.
+
+        :param Variable var: variable to fix
+        :param val: float, the fix value
+        :return: tuple (infeasible, fixed) of booleans
+
+        """
+        cdef SCIP_Bool infeasible
+        cdef SCIP_Bool fixed
+        PY_SCIP_CALL(SCIPfixVar(self._scip, var.scip_var, val, &infeasible, &fixed))
+        return infeasible, fixed
+
+    def delVar(self, Variable var):
+        """Delete a variable.
+
+        :param var: the variable which shall be deleted
+        :return: bool, was deleting succesful
+
+        """
+        cdef SCIP_Bool deleted
+        if var.ptr() in self._modelvars:
+            del self._modelvars[var.ptr()]
+        PY_SCIP_CALL(SCIPdelVar(self._scip, var.scip_var, &deleted))
+        return deleted
+
+    def tightenVarLb(self, Variable var, lb, force=False):
+        """Tighten the lower bound in preprocessing or current node, if the bound is tighter.
+
+        :param var: SCIP variable
+        :param lb: possible new lower bound
+        :param force: force tightening even if below bound strengthening tolerance
+        :return: tuple of bools, (infeasible, tightened)
+                    infeasible: whether new domain is empty
+                    tightened: whether the bound was tightened
+
+        """
+        cdef SCIP_Bool infeasible
+        cdef SCIP_Bool tightened
+        PY_SCIP_CALL(SCIPtightenVarLb(self._scip, var.scip_var, lb, force, &infeasible, &tightened))
+        return infeasible, tightened
+
+    def tightenVarUb(self, Variable var, ub, force=False):
+        """Tighten the upper bound in preprocessing or current node, if the bound is tighter.
+
+        :param var: SCIP variable
+        :param ub: possible new upper bound
+        :param force: force tightening even if below bound strengthening tolerance
+        :return: tuple of bools, (infeasible, tightened)
+                    infeasible: whether new domain is empty
+                    tightened: whether the bound was tightened
+
+        """
+        cdef SCIP_Bool infeasible
+        cdef SCIP_Bool tightened
+        PY_SCIP_CALL(SCIPtightenVarUb(self._scip, var.scip_var, ub, force, &infeasible, &tightened))
+        return infeasible, tightened
+
+    def tightenVarUbGlobal(self, Variable var, ub, force=False):
+        """Tighten the global upper bound, if the bound is tighter.
+
+        :param var: SCIP variable
+        :param ub: possible new upper bound
+        :param force: force tightening even if below bound strengthening tolerance
+        :return: tuple of bools, (infeasible, tightened)
+                    infeasible: whether new domain is empty
+                    tightened: whether the bound was tightened
+
+        """
+        cdef SCIP_Bool infeasible
+        cdef SCIP_Bool tightened
+        PY_SCIP_CALL(SCIPtightenVarUbGlobal(self._scip, var.scip_var, ub, force, &infeasible, &tightened))
+        return infeasible, tightened
+
+    def tightenVarLbGlobal(self, Variable var, lb, force=False):
+        """Tighten the global upper bound, if the bound is tighter.
+
+        :param var: SCIP variable
+        :param lb: possible new upper bound
+        :param force: force tightening even if below bound strengthening tolerance
+        :return: tuple of bools, (infeasible, tightened)
+                    infeasible: whether new domain is empty
+                    tightened: whether the bound was tightened
+
+        """
+        cdef SCIP_Bool infeasible
+        cdef SCIP_Bool tightened
+        PY_SCIP_CALL(SCIPtightenVarLbGlobal(self._scip, var.scip_var, lb, force, &infeasible, &tightened))
+        return infeasible, tightened
+
+    def chgVarLb(self, Variable var, lb):
+        """Changes the lower bound of the specified variable.
+
+        :param Variable var: variable to change bound of
+        :param lb: new lower bound (set to None for -infinity)
+
+        """
+        if lb is None:
+           lb = -SCIPinfinity(self._scip)
+        PY_SCIP_CALL(SCIPchgVarLb(self._scip, var.scip_var, lb))
+
+    def chgVarUb(self, Variable var, ub):
+        """Changes the upper bound of the specified variable.
+
+        :param Variable var: variable to change bound of
+        :param ub: new upper bound (set to None for +infinity)
+
+        """
+        if ub is None:
+           ub = SCIPinfinity(self._scip)
+        PY_SCIP_CALL(SCIPchgVarUb(self._scip, var.scip_var, ub))
+
+    def chgVarLbGlobal(self, Variable var, lb):
+        """Changes the global lower bound of the specified variable.
+
+        :param Variable var: variable to change bound of
+        :param lb: new lower bound (set to None for -infinity)
+
+        """
+        if lb is None:
+           lb = -SCIPinfinity(self._scip)
+        PY_SCIP_CALL(SCIPchgVarLbGlobal(self._scip, var.scip_var, lb))
+
+    def chgVarUbGlobal(self, Variable var, ub):
+        """Changes the global upper bound of the specified variable.
+
+        :param Variable var: variable to change bound of
+        :param ub: new upper bound (set to None for +infinity)
+
+        """
+        if ub is None:
+           ub = SCIPinfinity(self._scip)
+        PY_SCIP_CALL(SCIPchgVarUbGlobal(self._scip, var.scip_var, ub))
+
+    def chgVarLbNode(self, Node node, Variable var, lb):
+        """Changes the lower bound of the specified variable at the given node.
+
+        :param Variable var: variable to change bound of
+        :param lb: new lower bound (set to None for -infinity)
+        """
+
+        if lb is None:
+           lb = -SCIPinfinity(self._scip)
+        PY_SCIP_CALL(SCIPchgVarLbNode(self._scip, node.scip_node, var.scip_var, lb))
+
+    def chgVarUbNode(self, Node node, Variable var, ub):
+        """Changes the upper bound of the specified variable at the given node.
+
+        :param Variable var: variable to change bound of
+        :param ub: new upper bound (set to None for +infinity)
+
+        """
+        if ub is None:
+           ub = SCIPinfinity(self._scip)
+        PY_SCIP_CALL(SCIPchgVarUbNode(self._scip, node.scip_node, var.scip_var, ub))
+
+    def chgVarType(self, Variable var, vtype):
+        """Changes the type of a variable
+
+        :param Variable var: variable to change type of
+        :param vtype: new variable type
+
+        """
+        cdef SCIP_Bool infeasible
+        if vtype in ['C', 'CONTINUOUS']:
+            PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_CONTINUOUS, &infeasible))
+        elif vtype in ['B', 'BINARY']:
+            PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_BINARY, &infeasible))
+        elif vtype in ['I', 'INTEGER']:
+            PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_INTEGER, &infeasible))
+        elif vtype in ['M', 'IMPLINT']:
+            PY_SCIP_CALL(SCIPchgVarType(self._scip, var.scip_var, SCIP_VARTYPE_IMPLINT, &infeasible))
+        else:
+            raise Warning("unrecognized variable type")
+        if infeasible:
+            print('could not change variable type of variable %s' % var)
+
+    def getVars(self, transformed=False):
+        """Retrieve all variables.
+
+        :param transformed: get transformed variables instead of original (Default value = False)
+
+        """
+        cdef SCIP_VAR** _vars
+        cdef SCIP_VAR* _var
+        cdef int _nvars
+        vars = []
+
+        if transformed:
+            _vars = SCIPgetVars(self._scip)
+            _nvars = SCIPgetNVars(self._scip)
+        else:
+            _vars = SCIPgetOrigVars(self._scip)
+            _nvars = SCIPgetNOrigVars(self._scip)
+
+        for i in range(_nvars):
+            ptr = (_vars[i])
+
+            # check whether the corresponding variable exists already
+            if ptr in self._modelvars:
+                vars.append(self._modelvars[ptr])
+            else:
+                # create a new variable
+                var = Variable.create(_vars[i])
+                assert var.ptr() == ptr
+                self._modelvars[ptr] = var
+                vars.append(var)
+
+        return vars
+
+    def getNVars(self, transformed=True):
+        """Retrieve number of variables in the problems.
+        
+        :param transformed: get transformed variables instead of original (Default value = True)
+        """
+        if transformed:
+            return SCIPgetNVars(self._scip)
+        else:
+            return SCIPgetNOrigVars(self._scip)
+
+    def getNIntVars(self):
+        """gets number of integer active problem variables"""
+        return SCIPgetNIntVars(self._scip)
+
+    def getNBinVars(self):
+        """gets number of binary active problem variables"""
+        return SCIPgetNBinVars(self._scip)
+    
+    def getVarDict(self):
+        """gets dictionary with variables names as keys and current variable values as items"""
+        var_dict = {}
+        for var in self.getVars():
+            var_dict[var.name] = self.getVal(var)
+        return var_dict
+
+    def updateNodeLowerbound(self, Node node, lb):
+        """if given value is larger than the node's lower bound (in transformed problem),
+        sets the node's lower bound to the new value
+
+        :param node: Node, the node to update
+        :param newbound: float, new bound (if greater) for the node
+
+        """
+        PY_SCIP_CALL(SCIPupdateNodeLowerbound(self._scip, node.scip_node, lb))
+    
+    def relax(self):
+        """Relaxes the integrality restrictions of the model"""
+        if self.getStage() != SCIP_STAGE_PROBLEM:
+            raise Warning("method can only be called in stage PROBLEM")
+
+        for var in self.getVars():
+            self.chgVarType(var, "C")
+
+    # Node methods
+    def getBestChild(self):
+        """gets the best child of the focus node w.r.t. the node selection strategy."""
+        return Node.create(SCIPgetBestChild(self._scip))
+
+    def getBestSibling(self):
+        """gets the best sibling of the focus node w.r.t. the node selection strategy."""
+        return Node.create(SCIPgetBestSibling(self._scip))
+
+    def getBestLeaf(self):
+        """gets the best leaf from the node queue w.r.t. the node selection strategy."""
+        return Node.create(SCIPgetBestLeaf(self._scip))
+
+    def getBestNode(self):
+        """gets the best node from the tree (child, sibling, or leaf) w.r.t. the node selection strategy."""
+        return Node.create(SCIPgetBestNode(self._scip))
+
+    def getBestboundNode(self):
+        """gets the node with smallest lower bound from the tree (child, sibling, or leaf)."""
+        return Node.create(SCIPgetBestboundNode(self._scip))
+
+    def getOpenNodes(self):
+        """access to all data of open nodes (leaves, children, and siblings)
+
+        :return: three lists containing open leaves, children, siblings
+        """
+        cdef SCIP_NODE** _leaves
+        cdef SCIP_NODE** _children
+        cdef SCIP_NODE** _siblings
+        cdef int _nleaves
+        cdef int _nchildren
+        cdef int _nsiblings
+
+        PY_SCIP_CALL(SCIPgetOpenNodesData(self._scip, &_leaves, &_children, &_siblings, &_nleaves, &_nchildren, &_nsiblings))
+
+        leaves   = [Node.create(_leaves[i]) for i in range(_nleaves)]
+        children = [Node.create(_children[i]) for i in range(_nchildren)]
+        siblings = [Node.create(_siblings[i]) for i in range(_nsiblings)]
+
+        return leaves, children, siblings
+
+    def repropagateNode(self, Node node):
+        """marks the given node to be propagated again the next time a node of its subtree is processed"""
+        PY_SCIP_CALL(SCIPrepropagateNode(self._scip, node.scip_node))
+
+
+    # LP Methods
+    def getLPSolstat(self):
+        """Gets solution status of current LP"""
+        return SCIPgetLPSolstat(self._scip)
+
+
+    def constructLP(self):
+        """makes sure that the LP of the current node is loaded and
+         may be accessed through the LP information methods
+
+        :return:  bool cutoff, i.e. can the node be cut off?
+
+        """
+        cdef SCIP_Bool cutoff
+        PY_SCIP_CALL(SCIPconstructLP(self._scip, &cutoff))
+        return cutoff
+
+    def getLPObjVal(self):
+        """gets objective value of current LP (which is the sum of column and loose objective value)"""
+
+        return SCIPgetLPObjval(self._scip)
+
+    def getLPColsData(self):
+        """Retrieve current LP columns"""
+        cdef SCIP_COL** cols
+        cdef int ncols
+
+        PY_SCIP_CALL(SCIPgetLPColsData(self._scip, &cols, &ncols))
+        return [Column.create(cols[i]) for i in range(ncols)]
+
+    def getLPRowsData(self):
+        """Retrieve current LP rows"""
+        cdef SCIP_ROW** rows
+        cdef int nrows
+
+        PY_SCIP_CALL(SCIPgetLPRowsData(self._scip, &rows, &nrows))
+        return [Row.create(rows[i]) for i in range(nrows)]
+
+    def getNLPRows(self):
+        """Retrieve the number of rows currently in the LP"""
+        return SCIPgetNLPRows(self._scip)
+
+    def getNLPCols(self):
+        """Retrieve the number of cols currently in the LP"""
+        return SCIPgetNLPCols(self._scip)
+
+    def getLPBasisInd(self):
+        """Gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1"""
+        cdef int nrows = SCIPgetNLPRows(self._scip)
+        cdef int* inds =  malloc(nrows * sizeof(int))
+
+        PY_SCIP_CALL(SCIPgetLPBasisInd(self._scip, inds))
+        result = [inds[i] for i in range(nrows)]
+        free(inds)
+        return result
+
+    def getLPBInvRow(self, row):
+        """gets a row from the inverse basis matrix B^-1"""
+        # TODO: sparsity information
+        cdef int nrows = SCIPgetNLPRows(self._scip)
+        cdef SCIP_Real* coefs =  malloc(nrows * sizeof(SCIP_Real))
+
+        PY_SCIP_CALL(SCIPgetLPBInvRow(self._scip, row, coefs, NULL, NULL))
+        result = [coefs[i] for i in range(nrows)]
+        free(coefs)
+        return result
+
+    def getLPBInvARow(self, row):
+        """gets a row from B^-1 * A"""
+        # TODO: sparsity information
+        cdef int ncols = SCIPgetNLPCols(self._scip)
+        cdef SCIP_Real* coefs =  malloc(ncols * sizeof(SCIP_Real))
+
+        PY_SCIP_CALL(SCIPgetLPBInvARow(self._scip, row, NULL, coefs, NULL, NULL))
+        result = [coefs[i] for i in range(ncols)]
+        free(coefs)
+        return result
+
+    def isLPSolBasic(self):
+        """returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis"""
+        return SCIPisLPSolBasic(self._scip)
+
+    #TODO: documentation!!
+    # LP Row Methods
+    def createEmptyRowSepa(self, Sepa sepa, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True):
+        """creates and captures an LP row without any coefficients from a separator
+
+        :param sepa: separator that creates the row
+        :param name: name of row (Default value = "row")
+        :param lhs: left hand side of row (Default value = 0)
+        :param rhs: right hand side of row (Default value = None)
+        :param local: is row only valid locally? (Default value = True)
+        :param modifiable: is row modifiable during node processing (subject to column generation)? (Default value = False)
+        :param removable: should the row be removed from the LP due to aging or cleanup? (Default value = True)
+        """
+        cdef SCIP_ROW* row
+        lhs =  -SCIPinfinity(self._scip) if lhs is None else lhs
+        rhs =  SCIPinfinity(self._scip) if rhs is None else rhs
+        scip_sepa = SCIPfindSepa(self._scip, str_conversion(sepa.name))
+        PY_SCIP_CALL(SCIPcreateEmptyRowSepa(self._scip, &row, scip_sepa, str_conversion(name), lhs, rhs, local, modifiable, removable))
+        PyRow = Row.create(row)
+        return PyRow
+
+    def createEmptyRowUnspec(self, name="row", lhs = 0.0, rhs = None, local = True, modifiable = False, removable = True):
+        """creates and captures an LP row without any coefficients from an unspecified source
+
+        :param name: name of row (Default value = "row")
+        :param lhs: left hand side of row (Default value = 0)
+        :param rhs: right hand side of row (Default value = None)
+        :param local: is row only valid locally? (Default value = True)
+        :param modifiable: is row modifiable during node processing (subject to column generation)? (Default value = False)
+        :param removable: should the row be removed from the LP due to aging or cleanup? (Default value = True)
+        """
+        cdef SCIP_ROW* row
+        lhs =  -SCIPinfinity(self._scip) if lhs is None else lhs
+        rhs =  SCIPinfinity(self._scip) if rhs is None else rhs
+        PY_SCIP_CALL(SCIPcreateEmptyRowUnspec(self._scip, &row, str_conversion(name), lhs, rhs, local, modifiable, removable))
+        PyRow = Row.create(row)
+        return PyRow
+
+    def getRowActivity(self, Row row):
+        """returns the activity of a row in the last LP or pseudo solution"""
+        return SCIPgetRowActivity(self._scip, row.scip_row)
+
+    def getRowLPActivity(self, Row row):
+        """returns the activity of a row in the last LP solution"""
+        return SCIPgetRowLPActivity(self._scip, row.scip_row)
+
+    # TODO: do we need this? (also do we need release var??)
+    def releaseRow(self, Row row not None):
+        """decreases usage counter of LP row, and frees memory if necessary"""
+        PY_SCIP_CALL(SCIPreleaseRow(self._scip, &row.scip_row))
+
+    def cacheRowExtensions(self, Row row not None):
+        """informs row, that all subsequent additions of variables to the row should be cached and not directly applied;
+        after all additions were applied, flushRowExtensions() must be called;
+        while the caching of row extensions is activated, information methods of the row give invalid results;
+        caching should be used, if a row is build with addVarToRow() calls variable by variable to increase the performance"""
+        PY_SCIP_CALL(SCIPcacheRowExtensions(self._scip, row.scip_row))
+
+    def flushRowExtensions(self, Row row not None):
+        """flushes all cached row extensions after a call of cacheRowExtensions() and merges coefficients with equal columns into a single coefficient"""
+        PY_SCIP_CALL(SCIPflushRowExtensions(self._scip, row.scip_row))
+
+    def addVarToRow(self, Row row not None, Variable var not None, value):
+        """resolves variable to columns and adds them with the coefficient to the row"""
+        PY_SCIP_CALL(SCIPaddVarToRow(self._scip, row.scip_row, var.scip_var, value))
+
+    def printRow(self, Row row not None):
+        """Prints row."""
+        PY_SCIP_CALL(SCIPprintRow(self._scip, row.scip_row, NULL))
+
+    def getRowNumIntCols(self, Row row):
+        """Returns number of intergal columns in the row"""
+        return SCIPgetRowNumIntCols(self._scip, row.scip_row)
+
+    def getRowObjParallelism(self, Row row):
+        """Returns 1 if the row is parallel, and 0 if orthogonal"""
+        return SCIPgetRowObjParallelism(self._scip, row.scip_row)
+
+    def getRowParallelism(self, Row row1, Row row2, orthofunc=101):
+        """Returns the degree of parallelism between hyplerplanes. 1 if perfectly parallel, 0 if orthognal.
+        101 in this case is an 'e' (euclidean) in ASCII. The other accpetable input is 100 (d for discrete)."""
+        return SCIProwGetParallelism(row1.scip_row, row2.scip_row, orthofunc)
+
+    def getRowDualSol(self, Row row):
+        """Gets the dual LP solution of a row"""
+        return SCIProwGetDualsol(row.scip_row)
+
+    # Cutting Plane Methods
+    def addPoolCut(self, Row row not None):
+        """if not already existing, adds row to global cut pool"""
+        PY_SCIP_CALL(SCIPaddPoolCut(self._scip, row.scip_row))
+
+    def getCutEfficacy(self, Row cut not None, Solution sol = None):
+        """returns efficacy of the cut with respect to the given primal solution or the current LP solution: e = -feasibility/norm"""
+        return SCIPgetCutEfficacy(self._scip, NULL if sol is None else sol.sol, cut.scip_row)
+
+    def isCutEfficacious(self, Row cut not None, Solution sol = None):
+        """ returns whether the cut's efficacy with respect to the given primal solution or the current LP solution is greater than the minimal cut efficacy"""
+        return SCIPisCutEfficacious(self._scip, NULL if sol is None else sol.sol, cut.scip_row)
+
+    def getCutLPSolCutoffDistance(self, Row cut not None, Solution sol not None):
+        """ returns row's cutoff distance in the direction of the given primal solution"""
+        return SCIPgetCutLPSolCutoffDistance(self._scip, sol.sol, cut.scip_row)
+
+    def addCut(self, Row cut not None, forcecut = False):
+        """adds cut to separation storage and returns whether cut has been detected to be infeasible for local bounds"""
+        cdef SCIP_Bool infeasible
+        PY_SCIP_CALL(SCIPaddRow(self._scip, cut.scip_row, forcecut, &infeasible))
+        return infeasible
+
+    def getNCuts(self):
+        """Retrieve total number of cuts in storage"""
+        return SCIPgetNCuts(self._scip)
+
+    def getNCutsApplied(self):
+        """Retrieve number of currently applied cuts"""
+        return SCIPgetNCutsApplied(self._scip)
+
+    def getNSepaRounds(self):
+        """Retrieve the number of separation rounds that have been performed
+        at the current node"""
+        return SCIPgetNSepaRounds(self._scip)
+
+    def separateSol(self, Solution sol = None, pretendroot = False, allowlocal = True, onlydelayed = False):
+        """separates the given primal solution or the current LP solution by calling the separators and constraint handlers'
+        separation methods;
+        the generated cuts are stored in the separation storage and can be accessed with the methods SCIPgetCuts() and
+        SCIPgetNCuts();
+        after evaluating the cuts, you have to call SCIPclearCuts() in order to remove the cuts from the
+        separation storage;
+        it is possible to call SCIPseparateSol() multiple times with different solutions and evaluate the found cuts
+        afterwards
+        :param Solution sol: solution to separate, None to use current lp solution (Default value = None)
+        :param pretendroot: should the cut separators be called as if we are at the root node? (Default value = "False")
+        :param allowlocal: should the separator be asked to separate local cuts (Default value = True)
+        :param onlydelayed: should only separators be called that were delayed in the previous round? (Default value = False)
+        returns
+        delayed -- whether a separator was delayed
+        cutoff -- whether the node can be cut off
+        """
+        cdef SCIP_Bool delayed
+        cdef SCIP_Bool cutoff
+
+        PY_SCIP_CALL( SCIPseparateSol(self._scip, NULL if sol is None else sol.sol, pretendroot, allowlocal, onlydelayed, &delayed, &cutoff) )
+        return delayed, cutoff
+
+    def _createConsLinear(self, ExprCons lincons, **kwargs):
+        assert isinstance(lincons, ExprCons), "given constraint is not ExprCons but %s" % lincons.__class__.__name__
+
+        assert lincons.expr.degree() <= 1, "given constraint is not linear, degree == %d" % lincons.expr.degree()
+        terms = lincons.expr.terms
+
+        cdef SCIP_CONS* scip_cons
+
+        cdef int nvars = len(terms.items())
+
+        vars_array =  malloc(nvars * sizeof(SCIP_VAR*))
+        coeffs_array =  malloc(nvars * sizeof(SCIP_Real))
+
+        for i, (key, coeff) in enumerate(terms.items()):
+            vars_array[i] = (key[0]).scip_var
+            coeffs_array[i] = coeff
+
+        PY_SCIP_CALL(SCIPcreateConsLinear(
+            self._scip, &scip_cons, str_conversion(kwargs['name']), nvars, vars_array, coeffs_array,
+            kwargs['lhs'], kwargs['rhs'], kwargs['initial'],
+            kwargs['separate'], kwargs['enforce'], kwargs['check'],
+            kwargs['propagate'], kwargs['local'], kwargs['modifiable'],
+            kwargs['dynamic'], kwargs['removable'], kwargs['stickingatnode']))
+
+        PyCons = Constraint.create(scip_cons)
+
+        free(vars_array)
+        free(coeffs_array)
+        return PyCons
+
+    def _createConsQuadratic(self, ExprCons quadcons, **kwargs):
+        terms = quadcons.expr.terms
+        assert quadcons.expr.degree() <= 2, "given constraint is not quadratic, degree == %d" % quadcons.expr.degree()
+
+        cdef SCIP_CONS* scip_cons
+        cdef SCIP_EXPR* prodexpr
+        PY_SCIP_CALL(SCIPcreateConsQuadraticNonlinear(
+            self._scip, &scip_cons, str_conversion(kwargs['name']),
+            0, NULL, NULL,        # linear
+            0, NULL, NULL, NULL,  # quadratc
+            kwargs['lhs'], kwargs['rhs'],
+            kwargs['initial'], kwargs['separate'], kwargs['enforce'],
+            kwargs['check'], kwargs['propagate'], kwargs['local'],
+            kwargs['modifiable'], kwargs['dynamic'], kwargs['removable']))
+
+        for v, c in terms.items():
+            if len(v) == 1: # linear
+                var = v[0]
+                PY_SCIP_CALL(SCIPaddLinearVarNonlinear(self._scip, scip_cons, var.scip_var, c))
+            else: # quadratic
+                assert len(v) == 2, 'term length must be 1 or 2 but it is %s' % len(v)
+
+                varexprs =  malloc(2 * sizeof(SCIP_EXPR*))
+                var1, var2 = v[0], v[1]
+                PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[0], var1.scip_var, NULL, NULL) )
+                PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &varexprs[1], var2.scip_var, NULL, NULL) )
+                PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &prodexpr, 2, varexprs, 1.0, NULL, NULL) )
+
+                PY_SCIP_CALL( SCIPaddExprNonlinear(self._scip, scip_cons, prodexpr, c) )
+
+                PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &prodexpr) )
+                PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[1]) )
+                PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &varexprs[0]) )
+                free(varexprs)
+
+        PyCons = Constraint.create(scip_cons)
+
+        return PyCons
+
+    def _createConsNonlinear(self, cons, **kwargs):
+        cdef SCIP_EXPR* expr
+        cdef SCIP_EXPR** varexprs
+        cdef SCIP_EXPR** monomials
+        cdef int* idxs
+        cdef SCIP_CONS* scip_cons
+
+        terms = cons.expr.terms
+
+        # collect variables
+        variables = {var.ptr():var for term in terms for var in term}
+        variables = list(variables.values())
+        varindex = {var.ptr():idx for (idx,var) in enumerate(variables)}
+
+        # create monomials for terms
+        monomials =  malloc(len(terms) * sizeof(SCIP_EXPR*))
+        termcoefs =  malloc(len(terms) * sizeof(SCIP_Real))
+        for i, (term, coef) in enumerate(terms.items()):
+            termvars =  malloc(len(term) * sizeof(SCIP_VAR*))
+            for j, var in enumerate(term):
+                termvars[j] = (var).scip_var
+            PY_SCIP_CALL( SCIPcreateExprMonomial(self._scip, &monomials[i], len(term), termvars, NULL, NULL, NULL) )
+            termcoefs[i] = coef
+            free(termvars)
+
+        # create polynomial from monomials
+        PY_SCIP_CALL( SCIPcreateExprSum(self._scip, &expr, len(terms), monomials, termcoefs, 0.0, NULL, NULL))
+
+        # create nonlinear constraint for expr
+        PY_SCIP_CALL( SCIPcreateConsNonlinear(
+            self._scip,
+            &scip_cons,
+            str_conversion(kwargs['name']),
+            expr,
+            kwargs['lhs'],
+            kwargs['rhs'],
+            kwargs['initial'],
+            kwargs['separate'],
+            kwargs['enforce'],
+            kwargs['check'],
+            kwargs['propagate'],
+            kwargs['local'],
+            kwargs['modifiable'],
+            kwargs['dynamic'],
+            kwargs['removable']) )
+
+        PyCons = Constraint.create(scip_cons)
+
+        PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &expr) )
+        for i in range(len(terms)):
+            PY_SCIP_CALL(SCIPreleaseExpr(self._scip, &monomials[i]))
+        free(monomials)
+        free(termcoefs)
+        return PyCons
+
+    def _createConsGenNonlinear(self, cons, **kwargs):
+        cdef SCIP_EXPR** childrenexpr
+        cdef SCIP_EXPR** scipexprs
+        cdef SCIP_CONS* scip_cons
+        cdef int nchildren
+
+        # get arrays from python's expression tree
+        expr = cons.expr
+        nodes = expr_to_nodes(expr)
+
+        # in nodes we have a list of tuples: each tuple is of the form
+        # (operator, [indices]) where indices are the indices of the tuples
+        # that are the children of this operator. This is sorted,
+        # so we are going to do is:
+        # loop over the nodes and create the expression of each
+        # Note1: when the operator is Operator.const, [indices] stores the value
+        # Note2: we need to compute the number of variable operators to find out
+        # how many variables are there.
+        nvars = 0
+        for node in nodes:
+            if node[0] == Operator.varidx:
+                nvars += 1
+        vars =  malloc(nvars * sizeof(SCIP_VAR*))
+
+        varpos = 0
+        scipexprs =  malloc(len(nodes) * sizeof(SCIP_EXPR*))
+        for i,node in enumerate(nodes):
+            opidx = node[0]
+            if opidx == Operator.varidx:
+                assert len(node[1]) == 1
+                pyvar = node[1][0] # for vars we store the actual var!
+                PY_SCIP_CALL( SCIPcreateExprVar(self._scip, &scipexprs[i], (pyvar).scip_var, NULL, NULL) )
+                vars[varpos] = (pyvar).scip_var
+                varpos += 1
+                continue
+            if opidx == Operator.const:
+                assert len(node[1]) == 1
+                value = node[1][0]
+                PY_SCIP_CALL( SCIPcreateExprValue(self._scip, &scipexprs[i], value, NULL, NULL) )
+                continue
+            if opidx == Operator.add:
+                nchildren = len(node[1])
+                childrenexpr =  malloc(nchildren * sizeof(SCIP_EXPR*))
+                coefs =  malloc(nchildren * sizeof(SCIP_Real))
+                for c, pos in enumerate(node[1]):
+                    childrenexpr[c] = scipexprs[pos]
+                    coefs[c] = 1
+                PY_SCIP_CALL( SCIPcreateExprSum(self._scip, &scipexprs[i], nchildren, childrenexpr, coefs, 0, NULL, NULL))
+                free(coefs)
+                free(childrenexpr)
+                continue
+            if opidx == Operator.prod:
+                nchildren = len(node[1])
+                childrenexpr =  malloc(nchildren * sizeof(SCIP_EXPR*))
+                for c, pos in enumerate(node[1]):
+                    childrenexpr[c] = scipexprs[pos]
+                PY_SCIP_CALL( SCIPcreateExprProduct(self._scip, &scipexprs[i], nchildren, childrenexpr, 1, NULL, NULL) )
+                free(childrenexpr)
+                continue
+            if opidx == Operator.power:
+                # the second child is the exponent which is a const
+                valuenode = nodes[node[1][1]]
+                assert valuenode[0] == Operator.const
+                exponent = valuenode[1][0]
+                PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], exponent, NULL, NULL ))
+                continue
+            if opidx == Operator.exp:
+                assert len(node[1]) == 1
+                PY_SCIP_CALL( SCIPcreateExprExp(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL ))
+                continue
+            if opidx == Operator.log:
+                assert len(node[1]) == 1
+                PY_SCIP_CALL( SCIPcreateExprLog(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL ))
+                continue
+            if opidx == Operator.sqrt:
+                assert len(node[1]) == 1
+                PY_SCIP_CALL( SCIPcreateExprPow(self._scip, &scipexprs[i], scipexprs[node[1][0]], 0.5, NULL, NULL) )
+                continue
+            if opidx == Operator.sin:
+                assert len(node[1]) == 1
+                PY_SCIP_CALL( SCIPcreateExprSin(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) )
+                continue
+            if opidx == Operator.cos:
+                assert len(node[1]) == 1
+                PY_SCIP_CALL( SCIPcreateExprCos(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL) )
+                continue
+            if opidx == Operator.fabs:
+                assert len(node[1]) == 1
+                PY_SCIP_CALL( SCIPcreateExprAbs(self._scip, &scipexprs[i], scipexprs[node[1][0]], NULL, NULL ))
+                continue
+            # default:
+            raise NotImplementedError
+        assert varpos == nvars
+
+        # create nonlinear constraint for the expression root
+        PY_SCIP_CALL( SCIPcreateConsNonlinear(
+            self._scip,
+            &scip_cons,
+            str_conversion(kwargs['name']),
+            scipexprs[len(nodes) - 1],
+            kwargs['lhs'],
+            kwargs['rhs'],
+            kwargs['initial'],
+            kwargs['separate'],
+            kwargs['enforce'],
+            kwargs['check'],
+            kwargs['propagate'],
+            kwargs['local'],
+            kwargs['modifiable'],
+            kwargs['dynamic'],
+            kwargs['removable']) )
+        PyCons = Constraint.create(scip_cons)
+        for i in range(len(nodes)):
+            PY_SCIP_CALL( SCIPreleaseExpr(self._scip, &scipexprs[i]) )
+
+        # free more memory
+        free(scipexprs)
+        free(vars)
+
+        return PyCons
+
+    def createConsFromExpr(self, cons, name='', initial=True, separate=True,
+                enforce=True, check=True, propagate=True, local=False,
+                modifiable=False, dynamic=False, removable=False,
+                stickingatnode=False):
+        """Create a linear or nonlinear constraint without adding it to the SCIP problem. This is useful for creating disjunction constraints
+        without also enforcing the individual constituents. Currently, this can only be used as an argument to `.addConsElemDisjunction`. To add 
+        an individual linear/nonlinear constraint, prefer `.addCons()`.
+
+        :param cons: constraint object
+        :param name: the name of the constraint, generic name if empty (Default value = '')
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: should the constraint be propagated during node processing? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be  moved to a more global node? (Default value = False)
+        :return The created @ref scip#Constraint "Constraint" object.
+
+        """
+        if name == '':
+            name = 'c'+str(SCIPgetNConss(self._scip)+1)
+
+        kwargs = dict(name=name, initial=initial, separate=separate,
+                      enforce=enforce, check=check,
+                      propagate=propagate, local=local,
+                      modifiable=modifiable, dynamic=dynamic,
+                      removable=removable,
+                      stickingatnode=stickingatnode)
+        kwargs['lhs'] = -SCIPinfinity(self._scip) if cons._lhs is None else cons._lhs
+        kwargs['rhs'] =  SCIPinfinity(self._scip) if cons._rhs is None else cons._rhs
+
+        deg = cons.expr.degree()
+        if deg <= 1:
+            return self._createConsLinear(cons, **kwargs)
+        elif deg <= 2:
+            return self._createConsQuadratic(cons, **kwargs)
+        elif deg == float('inf'): # general nonlinear
+            return self._createConsGenNonlinear(cons, **kwargs)
+        else:
+            return self._createConsNonlinear(cons, **kwargs)
+
+    # Constraint functions
+    def addCons(self, cons, name='', initial=True, separate=True,
+                enforce=True, check=True, propagate=True, local=False,
+                modifiable=False, dynamic=False, removable=False,
+                stickingatnode=False):
+        """Add a linear or nonlinear constraint.
+
+        :param cons: constraint object
+        :param name: the name of the constraint, generic name if empty (Default value = '')
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: should the constraint be propagated during node processing? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be  moved to a more global node? (Default value = False)
+        :return The added @ref scip#Constraint "Constraint" object.
+
+        """
+        assert isinstance(cons, ExprCons), "given constraint is not ExprCons but %s" % cons.__class__.__name__
+
+        cdef SCIP_CONS* scip_cons
+
+        kwargs = dict(name=name, initial=initial, separate=separate,
+                      enforce=enforce, check=check,
+                      propagate=propagate, local=local,
+                      modifiable=modifiable, dynamic=dynamic,
+                      removable=removable,
+                      stickingatnode=stickingatnode)
+        #  we have to pass this back to a SCIP_CONS*
+        # object to create a new python constraint & handle constraint release
+        # correctly. Otherwise, segfaults when trying to query information
+        # about the created constraint later.
+        pycons_initial = self.createConsFromExpr(cons, **kwargs)
+        scip_cons = (pycons_initial).scip_cons
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+        pycons = Constraint.create(scip_cons)
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        return pycons
+
+    def addConss(self, conss, name='', initial=True, separate=True,
+                 enforce=True, check=True, propagate=True, local=False,
+                 modifiable=False, dynamic=False, removable=False,
+                 stickingatnode=False):
+        """Adds multiple linear or quadratic constraints.
+
+        Each of the constraints is added to the model using Model.addCons().
+
+        For all parameters, except @p conss, this method behaves differently depending on the type of the passed argument:
+          1. If the value is iterable, it must be of the same length as @p conss. For each constraint, Model.addCons() will be called with the value at the corresponding index.
+          2. Else, the (default) value will be applied to all of the constraints.
+
+        :param conss An iterable of constraint objects. Any iterable will be converted into a list before further processing.
+        :param name: the names of the constraints, generic name if empty (Default value = ''). If a single string is passed, it will be suffixed by an underscore and the enumerated index of the constraint (starting with 0).
+        :param initial: should the LP relaxation of constraints be in the initial LP? (Default value = True)
+        :param separate: should the constraints be separated during LP processing? (Default value = True)
+        :param enforce: should the constraints be enforced during node processing? (Default value = True)
+        :param check: should the constraints be checked for feasibility? (Default value = True)
+        :param propagate: should the constraints be propagated during node processing? (Default value = True)
+        :param local: are the constraints only valid locally? (Default value = False)
+        :param modifiable: are the constraints modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: are the constraints subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraints always be kept at the node where it was added, even if it may be  @oved to a more global node? (Default value = False)
+        :return A list of added @ref scip#Constraint "Constraint" objects.
+
+        :see addCons()
+        """
+        def ensure_iterable(elem, length):
+            if isinstance(elem, Iterable):
+                return elem
+            else:
+                return list(repeat(elem, length))
+
+        assert isinstance(conss, Iterable), "Given constraint list is not iterable."
+
+        conss = list(conss)
+        n_conss = len(conss)
+
+        if isinstance(name, str):
+            if name == "":
+                name = ["" for idx in range(n_conss)]
+            else:
+                name = ["%s_%s" % (name, idx) for idx in range(n_conss)]
+        initial = ensure_iterable(initial, n_conss)
+        separate = ensure_iterable(separate, n_conss)
+        enforce = ensure_iterable(enforce, n_conss)
+        check = ensure_iterable(check, n_conss)
+        propagate = ensure_iterable(propagate, n_conss)
+        local = ensure_iterable(local, n_conss)
+        modifiable = ensure_iterable(modifiable, n_conss)
+        dynamic = ensure_iterable(dynamic, n_conss)
+        removable = ensure_iterable(removable, n_conss)
+        stickingatnode = ensure_iterable(stickingatnode, n_conss)
+
+        constraints = []
+        for i, cons in enumerate(conss):
+            constraints.append(
+                self.addCons(cons, name[i], initial[i], separate[i], enforce[i],
+                             check[i], propagate[i], local[i], modifiable[i],
+                             dynamic[i], removable[i], stickingatnode[i])
+            )
+
+        return constraints
+
+    def addConsDisjunction(self, conss, name = '', initial = True, 
+        relaxcons = None, enforce=True, check =True, 
+        local=False, modifiable = False, dynamic = False):
+        """Add a disjunction constraint.
+
+        :param Iterable[Constraint] conss: An iterable of constraint objects to be included initially in the disjunction. Currently, these must be expressions.
+        :param name: the name of the disjunction constraint.
+        :param initial: should the LP relaxation of disjunction constraint be in the initial LP? (Default value = True)
+        :param relaxcons: a conjunction constraint containing the linear relaxation of the disjunction constraint, or None. (Default value = None)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :return The added @ref scip#Constraint "Constraint" object.
+        """
+        def ensure_iterable(elem, length):
+            if isinstance(elem, Iterable):
+                return elem
+            else:
+                return list(repeat(elem, length))
+        assert isinstance(conss, Iterable), "Given constraint list is not iterable"
+
+        conss = list(conss)
+        n_conss = len(conss)
+
+        cdef SCIP_CONS* disj_cons
+
+        cdef SCIP_CONS* scip_cons
+
+        cdef SCIP_EXPR* scip_expr
+
+        PY_SCIP_CALL(SCIPcreateConsDisjunction(
+            self._scip, &disj_cons, str_conversion(name), 0, &scip_cons, NULL, 
+            initial, enforce, check, local, modifiable, dynamic
+        ))
+
+
+        # TODO add constraints to disjunction
+        for i, cons in enumerate(conss):
+            pycons = self.createConsFromExpr(cons, name=name, initial = initial,
+                                            enforce=enforce, check=check,
+                                            local=local, modifiable=modifiable, dynamic=dynamic
+                                            )
+            PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip,disj_cons, (pycons).scip_cons))
+            PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(pycons).scip_cons))
+        PY_SCIP_CALL(SCIPaddCons(self._scip, disj_cons))
+        PyCons = Constraint.create(disj_cons)
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &disj_cons))
+        return PyCons
+
+    def addConsElemDisjunction(self, Constraint disj_cons, Constraint cons):
+        """Appends a constraint to a disjunction.
+
+        :param Constraint disj_cons: the disjunction constraint to append to.
+        :param Constraint cons: the Constraint to append
+        :return The disjunction constraint with added @ref scip#Constraint object.
+        """
+        PY_SCIP_CALL(SCIPaddConsElemDisjunction(self._scip, (disj_cons).scip_cons, (cons).scip_cons))
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &(cons).scip_cons))
+        return disj_cons
+
+    def getConsNVars(self, Constraint constraint):
+        """
+        Gets number of variables in a constraint.
+
+        :param constraint: Constraint to get the number of variables from.
+        """
+        cdef int nvars 
+        cdef SCIP_Bool success
+
+        PY_SCIP_CALL(SCIPgetConsNVars(self._scip, constraint.scip_cons, &nvars, &success))   
+
+        if not success:
+            conshdlr = SCIPconsGetHdlr(constraint.scip_cons)
+            conshdrlname = SCIPconshdlrGetName(conshdlr)
+            raise TypeError("The constraint handler %s does not have this functionality." % conshdrlname)
+
+        return nvars
+
+    def getConsVars(self, Constraint constraint):
+        """
+        Gets variables in a constraint.
+
+        :param constraint: Constraint to get the variables from.
+        """
+        cdef SCIP_Bool success
+        cdef int _nvars
+
+        SCIPgetConsNVars(self._scip, constraint.scip_cons, &_nvars, &success)
+
+        cdef SCIP_VAR** _vars =  malloc(_nvars * sizeof(SCIP_VAR*))
+        SCIPgetConsVars(self._scip, constraint.scip_cons, _vars, _nvars*sizeof(SCIP_VAR*), &success)
+
+        vars = []
+        for i in range(_nvars):
+            ptr = (_vars[i])
+            # check whether the corresponding variable exists already
+            if ptr in self._modelvars:
+                vars.append(self._modelvars[ptr])
+            else:
+                # create a new variable
+                var = Variable.create(_vars[i])
+                assert var.ptr() == ptr
+                self._modelvars[ptr] = var
+                vars.append(var)
+        return vars
+
+    def printCons(self, Constraint constraint):
+        return PY_SCIP_CALL(SCIPprintCons(self._scip, constraint.scip_cons, NULL))
+
+    # TODO Find a better way to retrieve a scip expression from a python expression. Consider making GenExpr include Expr, to avoid using Union. See PR #760.
+    from typing import Union
+    def addExprNonlinear(self, Constraint cons, expr: Union[Expr,GenExpr], float coef):
+        """
+        Add coef*expr to nonlinear constraint.
+        """
+        assert self.getStage() == 1, "addExprNonlinear cannot be called in stage %i." % self.getStage()
+        assert cons.isNonlinear(), "addExprNonlinear can only be called with nonlinear constraints."
+
+        cdef Constraint temp_cons
+        cdef SCIP_EXPR* scip_expr 
+
+        temp_cons = self.addCons(expr <= 0)
+        scip_expr = SCIPgetExprNonlinear(temp_cons.scip_cons)
+
+        PY_SCIP_CALL(SCIPaddExprNonlinear(self._scip, cons.scip_cons, scip_expr, coef))
+        self.delCons(temp_cons)
+
+    def addConsCoeff(self, Constraint cons, Variable var, coeff):
+        """Add coefficient to the linear constraint (if non-zero).
+
+        :param Constraint cons: constraint to be changed
+        :param Variable var: variable to be added
+        :param coeff: coefficient of new variable
+
+        """
+        PY_SCIP_CALL(SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, coeff))
+
+    def addConsNode(self, Node node, Constraint cons, Node validnode=None):
+        """Add a constraint to the given node
+
+        :param Node node: node to add the constraint to
+        :param Constraint cons: constraint to add
+        :param Node validnode: more global node where cons is also valid
+
+        """
+        if isinstance(validnode, Node):
+            PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, validnode.scip_node))
+        else:
+            PY_SCIP_CALL(SCIPaddConsNode(self._scip, node.scip_node, cons.scip_cons, NULL))
+        Py_INCREF(cons)
+
+    def addConsLocal(self, Constraint cons, Node validnode=None):
+        """Add a constraint to the current node
+
+        :param Constraint cons: constraint to add
+        :param Node validnode: more global node where cons is also valid
+
+        """
+        if isinstance(validnode, Node):
+            PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, validnode.scip_node))
+        else:
+            PY_SCIP_CALL(SCIPaddConsLocal(self._scip, cons.scip_cons, NULL))
+        Py_INCREF(cons)
+
+    def addConsSOS1(self, vars, weights=None, name="SOS1cons",
+                initial=True, separate=True, enforce=True, check=True,
+                propagate=True, local=False, dynamic=False,
+                removable=False, stickingatnode=False):
+        """Add an SOS1 constraint.
+
+        :param vars: list of variables to be included
+        :param weights: list of weights (Default value = None)
+        :param name: name of the constraint (Default value = "SOS1cons")
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: should the constraint be propagated during node processing? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)
+
+        """
+        cdef SCIP_CONS* scip_cons
+        cdef int _nvars
+
+        PY_SCIP_CALL(SCIPcreateConsSOS1(self._scip, &scip_cons, str_conversion(name), 0, NULL, NULL,
+            initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode))
+
+        if weights is None:
+            for v in vars:
+                var = v
+                PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, scip_cons, var.scip_var))
+        else:
+            nvars = len(vars)
+            for i in range(nvars):
+                var = vars[i]
+                PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, scip_cons, var.scip_var, weights[i]))
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+        return Constraint.create(scip_cons)
+
+    def addConsSOS2(self, vars, weights=None, name="SOS2cons",
+                initial=True, separate=True, enforce=True, check=True,
+                propagate=True, local=False, dynamic=False,
+                removable=False, stickingatnode=False):
+        """Add an SOS2 constraint.
+
+        :param vars: list of variables to be included
+        :param weights: list of weights (Default value = None)
+        :param name: name of the constraint (Default value = "SOS2cons")
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: is the constraint only valid locally? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)
+
+        """
+        cdef SCIP_CONS* scip_cons
+        cdef int _nvars
+
+        PY_SCIP_CALL(SCIPcreateConsSOS2(self._scip, &scip_cons, str_conversion(name), 0, NULL, NULL,
+            initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode))
+
+        if weights is None:
+            for v in vars:
+                var = v
+                PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, scip_cons, var.scip_var))
+        else:
+            nvars = len(vars)
+            for i in range(nvars):
+                var = vars[i]
+                PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, scip_cons, var.scip_var, weights[i]))
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+        return Constraint.create(scip_cons)      
+
+    def addConsAnd(self, vars, resvar, name="ANDcons",
+            initial=True, separate=True, enforce=True, check=True,
+            propagate=True, local=False, modifiable=False, dynamic=False,
+            removable=False, stickingatnode=False):
+        """Add an AND-constraint.
+        :param vars: list of BINARY variables to be included (operators)
+        :param resvar: BINARY variable (resultant)
+        :param name: name of the constraint (Default value = "ANDcons")
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: should the constraint be propagated during node processing? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)
+        """
+        cdef SCIP_CONS* scip_cons
+
+        nvars = len(vars)
+
+        _vars =  malloc(len(vars) * sizeof(SCIP_VAR*))
+        for idx, var in enumerate(vars):
+            _vars[idx] = (var).scip_var
+        _resVar = (resvar).scip_var
+
+        PY_SCIP_CALL(SCIPcreateConsAnd(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars,
+            initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode))
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+        pyCons = Constraint.create(scip_cons)
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        free(_vars)
+
+        return pyCons
+
+    def addConsOr(self, vars, resvar, name="ORcons",
+            initial=True, separate=True, enforce=True, check=True,
+            propagate=True, local=False, modifiable=False, dynamic=False,
+            removable=False, stickingatnode=False):
+        """Add an OR-constraint.
+        :param vars: list of BINARY variables to be included (operators)
+        :param resvar: BINARY variable (resultant)
+        :param name: name of the constraint (Default value = "ORcons")
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: should the constraint be propagated during node processing? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)
+        """
+        cdef SCIP_CONS* scip_cons
+
+        nvars = len(vars)
+
+        _vars =  malloc(len(vars) * sizeof(SCIP_VAR*))
+        for idx, var in enumerate(vars):
+            _vars[idx] = (var).scip_var
+        _resVar = (resvar).scip_var
+
+        PY_SCIP_CALL(SCIPcreateConsOr(self._scip, &scip_cons, str_conversion(name), _resVar, nvars, _vars,
+            initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode))
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+        pyCons = Constraint.create(scip_cons)
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        free(_vars)
+
+        return pyCons
+
+    def addConsXor(self, vars, rhsvar, name="XORcons",
+            initial=True, separate=True, enforce=True, check=True,
+            propagate=True, local=False, modifiable=False, dynamic=False,
+            removable=False, stickingatnode=False):
+        """Add a XOR-constraint.
+        :param vars: list of BINARY variables to be included (operators)
+        :param rhsvar: BOOLEAN value, explicit True, False or bool(obj) is needed (right-hand side)
+        :param name: name of the constraint (Default value = "XORcons")
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: should the constraint be propagated during node processing? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param modifiable: is the constraint modifiable (subject to column generation)? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)
+        """
+        cdef SCIP_CONS* scip_cons
+
+        nvars = len(vars)
+
+        assert type(rhsvar) is type(bool()), "Provide BOOLEAN value as rhsvar, you gave %s." % type(rhsvar)
+        _vars =  malloc(len(vars) * sizeof(SCIP_VAR*))
+        for idx, var in enumerate(vars):
+            _vars[idx] = (var).scip_var
+
+        PY_SCIP_CALL(SCIPcreateConsXor(self._scip, &scip_cons, str_conversion(name), rhsvar, nvars, _vars,
+            initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode))
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+        pyCons = Constraint.create(scip_cons)
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        free(_vars)
+
+        return pyCons
+
+    def addConsCardinality(self, consvars, cardval, indvars=None, weights=None, name="CardinalityCons",
+                initial=True, separate=True, enforce=True, check=True,
+                propagate=True, local=False, dynamic=False,
+                removable=False, stickingatnode=False):
+        """Add a cardinality constraint that allows at most 'cardval' many nonzero variables.
+
+        :param consvars: list of variables to be included
+        :param cardval: nonnegative integer
+        :param indvars: indicator variables indicating which variables may be treated as nonzero in cardinality constraint, or None if new indicator variables should be introduced automatically (Default value = None)
+        :param weights: weights determining the variable order, or None if variables should be ordered in the same way they were added to the constraint (Default value = None)
+        :param name: name of the constraint (Default value = "CardinalityCons")
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: should the constraint be propagated during node processing? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)
+
+        """
+        cdef SCIP_CONS* scip_cons
+        cdef SCIP_VAR* indvar
+
+        PY_SCIP_CALL(SCIPcreateConsCardinality(self._scip, &scip_cons, str_conversion(name), 0, NULL, cardval, NULL, NULL,
+            initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode))
+
+        # circumvent an annoying bug in SCIP 4.0.0 that does not allow uninitialized weights
+        if weights is None:
+            weights = list(range(1, len(consvars) + 1))
+
+        for i, v in enumerate(consvars):
+            var = v
+            if indvars:
+                indvar = (indvars[i]).scip_var
+            else:
+                indvar = NULL
+            if weights is None:
+                PY_SCIP_CALL(SCIPappendVarCardinality(self._scip, scip_cons, var.scip_var, indvar))
+            else:
+                PY_SCIP_CALL(SCIPaddVarCardinality(self._scip, scip_cons, var.scip_var, indvar, weights[i]))
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+        pyCons = Constraint.create(scip_cons)
+
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        return pyCons
+
+    def addConsIndicator(self, cons, binvar=None, activeone=True, name="IndicatorCons",
+                initial=True, separate=True, enforce=True, check=True,
+                propagate=True, local=False, dynamic=False,
+                removable=False, stickingatnode=False):
+        """Add an indicator constraint for the linear inequality 'cons'.
+
+        The 'binvar' argument models the redundancy of the linear constraint. A solution for which
+        'binvar' is 1 must satisfy the constraint.
+
+        :param cons: a linear inequality of the form "<="
+        :param binvar: binary indicator variable, or None if it should be created (Default value = None)
+        :param activeone: constraint should active if binvar is 1 (0 if activeone = False)
+        :param name: name of the constraint (Default value = "IndicatorCons")
+        :param initial: should the LP relaxation of constraint be in the initial LP? (Default value = True)
+        :param separate: should the constraint be separated during LP processing? (Default value = True)
+        :param enforce: should the constraint be enforced during node processing? (Default value = True)
+        :param check: should the constraint be checked for feasibility? (Default value = True)
+        :param propagate: should the constraint be propagated during node processing? (Default value = True)
+        :param local: is the constraint only valid locally? (Default value = False)
+        :param dynamic: is the constraint subject to aging? (Default value = False)
+        :param removable: should the relaxation be removed from the LP due to aging or cleanup? (Default value = False)
+        :param stickingatnode: should the constraint always be kept at the node where it was added, even if it may be moved to a more global node? (Default value = False)
+
+        """
+        assert isinstance(cons, ExprCons), "given constraint is not ExprCons but %s" % cons.__class__.__name__
+        cdef SCIP_CONS* scip_cons
+        cdef SCIP_VAR* _binVar
+        if cons._lhs is not None and cons._rhs is not None:
+            raise ValueError("expected inequality that has either only a left or right hand side")
+
+        if cons.expr.degree() > 1:
+            raise ValueError("expected linear inequality, expression has degree %d" % cons.expr.degree())
+
+        if cons._rhs is not None:
+            rhs =  cons._rhs
+            negate = False
+        else:
+            rhs = -cons._lhs
+            negate = True
+
+        if binvar is not None:
+            _binVar = (binvar).scip_var
+            if not activeone:
+                PY_SCIP_CALL(SCIPgetNegatedVar(self._scip, _binVar, &_binVar))
+        else:
+            _binVar = NULL
+
+        PY_SCIP_CALL(SCIPcreateConsIndicator(self._scip, &scip_cons, str_conversion(name), _binVar, 0, NULL, NULL, rhs,
+            initial, separate, enforce, check, propagate, local, dynamic, removable, stickingatnode))
+        terms = cons.expr.terms
+
+        for key, coeff in terms.items():
+            var = key[0]
+            if negate:
+                coeff = -coeff
+            PY_SCIP_CALL(SCIPaddVarIndicator(self._scip, scip_cons, var.scip_var, coeff))
+
+        PY_SCIP_CALL(SCIPaddCons(self._scip, scip_cons))
+        pyCons = Constraint.create(scip_cons)
+
+        PY_SCIP_CALL(SCIPreleaseCons(self._scip, &scip_cons))
+
+        return pyCons
+    
+    def getSlackVarIndicator(self, Constraint cons):
+        """Get slack variable of an indicator constraint.
+
+        :param Constraint cons: indicator constraint
+
+        """
+        cdef SCIP_VAR* var = SCIPgetSlackVarIndicator(cons.scip_cons);
+        return Variable.create(var)
+
+    def addPyCons(self, Constraint cons):
+        """Adds a customly created cons.
+
+        :param Constraint cons: constraint to add
+
+        """
+        PY_SCIP_CALL(SCIPaddCons(self._scip, cons.scip_cons))
+        Py_INCREF(cons)
+
+    def addVarSOS1(self, Constraint cons, Variable var, weight):
+        """Add variable to SOS1 constraint.
+
+        :param Constraint cons: SOS1 constraint
+        :param Variable var: new variable
+        :param weight: weight of new variable
+
+        """
+        PY_SCIP_CALL(SCIPaddVarSOS1(self._scip, cons.scip_cons, var.scip_var, weight))
+
+    def appendVarSOS1(self, Constraint cons, Variable var):
+        """Append variable to SOS1 constraint.
+
+        :param Constraint cons: SOS1 constraint
+        :param Variable var: variable to append
+
+        """
+        PY_SCIP_CALL(SCIPappendVarSOS1(self._scip, cons.scip_cons, var.scip_var))
+
+    def addVarSOS2(self, Constraint cons, Variable var, weight):
+        """Add variable to SOS2 constraint.
+
+        :param Constraint cons: SOS2 constraint
+        :param Variable var: new variable
+        :param weight: weight of new variable
+
+        """
+        PY_SCIP_CALL(SCIPaddVarSOS2(self._scip, cons.scip_cons, var.scip_var, weight))
+
+    def appendVarSOS2(self, Constraint cons, Variable var):
+        """Append variable to SOS2 constraint.
+
+        :param Constraint cons: SOS2 constraint
+        :param Variable var: variable to append
+
+        """
+        PY_SCIP_CALL(SCIPappendVarSOS2(self._scip, cons.scip_cons, var.scip_var))
+
+    def setInitial(self, Constraint cons, newInit):
+        """Set "initial" flag of a constraint.
+
+        Keyword arguments:
+        cons -- constraint
+        newInit -- new initial value
+        """
+        PY_SCIP_CALL(SCIPsetConsInitial(self._scip, cons.scip_cons, newInit))
+
+    def setRemovable(self, Constraint cons, newRem):
+        """Set "removable" flag of a constraint.
+
+        Keyword arguments:
+        cons -- constraint
+        newRem -- new removable value
+        """
+        PY_SCIP_CALL(SCIPsetConsRemovable(self._scip, cons.scip_cons, newRem))
+
+    def setEnforced(self, Constraint cons, newEnf):
+        """Set "enforced" flag of a constraint.
+
+        Keyword arguments:
+        cons -- constraint
+        newEnf -- new enforced value
+        """
+        PY_SCIP_CALL(SCIPsetConsEnforced(self._scip, cons.scip_cons, newEnf))
+
+    def setCheck(self, Constraint cons, newCheck):
+        """Set "check" flag of a constraint.
+
+        Keyword arguments:
+        cons -- constraint
+        newCheck -- new check value
+        """
+        PY_SCIP_CALL(SCIPsetConsChecked(self._scip, cons.scip_cons, newCheck))
+
+    def chgRhs(self, Constraint cons, rhs):
+        """Change right hand side value of a constraint.
+
+        :param Constraint cons: linear or quadratic constraint
+        :param rhs: new right hand side (set to None for +infinity)
+
+        """
+
+        if rhs is None:
+           rhs = SCIPinfinity(self._scip)
+
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if constype == 'linear':
+            PY_SCIP_CALL(SCIPchgRhsLinear(self._scip, cons.scip_cons, rhs))
+        elif constype == 'nonlinear':
+            PY_SCIP_CALL(SCIPchgRhsNonlinear(self._scip, cons.scip_cons, rhs))
+        else:
+            raise Warning("method cannot be called for constraints of type " + constype)
+
+    def chgLhs(self, Constraint cons, lhs):
+        """Change left hand side value of a constraint.
+
+        :param Constraint cons: linear or quadratic constraint
+        :param lhs: new left hand side (set to None for -infinity)
+
+        """
+
+        if lhs is None:
+           lhs = -SCIPinfinity(self._scip)
+
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if constype == 'linear':
+            PY_SCIP_CALL(SCIPchgLhsLinear(self._scip, cons.scip_cons, lhs))
+        elif constype == 'nonlinear':
+            PY_SCIP_CALL(SCIPchgLhsNonlinear(self._scip, cons.scip_cons, lhs))
+        else:
+            raise Warning("method cannot be called for constraints of type " + constype)
+
+    def getRhs(self, Constraint cons):
+        """Retrieve right hand side value of a constraint.
+
+        :param Constraint cons: linear or quadratic constraint
+
+        """
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if constype == 'linear':
+            return SCIPgetRhsLinear(self._scip, cons.scip_cons)
+        elif constype == 'quadratic':
+            return SCIPgetRhsNonlinear(cons.scip_cons)
+        else:
+            raise Warning("method cannot be called for constraints of type " + constype)
+
+    def getLhs(self, Constraint cons):
+        """Retrieve left hand side value of a constraint.
+
+        :param Constraint cons: linear or quadratic constraint
+
+        """
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if constype == 'linear':
+            return SCIPgetLhsLinear(self._scip, cons.scip_cons)
+        elif constype == 'quadratic':
+            return SCIPgetLhsNonlinear(cons.scip_cons)
+        else:
+            raise Warning("method cannot be called for constraints of type " + constype)
+
+    def chgCoefLinear(self, Constraint cons, Variable var, value):
+        """Changes coefficient of variable in linear constraint;
+        deletes the variable if coefficient is zero; adds variable if not yet contained in the constraint
+        This method may only be called during problem creation stage for an original constraint and variable.
+        This method requires linear time to search for occurences of the variable in the constraint data.
+
+        :param Constraint cons: linear constraint
+        :param Variable var: variable of constraint entry
+        :param value: new coefficient of constraint entry
+
+        """
+        PY_SCIP_CALL( SCIPchgCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) )
+
+    def delCoefLinear(self, Constraint cons, Variable var):
+        """Deletes variable from linear constraint
+        This method may only be called during problem creation stage for an original constraint and variable.
+        This method requires linear time to search for occurences of the variable in the constraint data.
+
+        :param Constraint cons: linear constraint
+        :param Variable var: variable of constraint entry
+
+        """
+
+        PY_SCIP_CALL( SCIPdelCoefLinear(self._scip, cons.scip_cons, var.scip_var) )
+
+    def addCoefLinear(self, Constraint cons, Variable var, value):
+        """Adds coefficient to linear constraint (if it is not zero)
+
+        :param Constraint cons: linear constraint
+        :param Variable var: variable of constraint entry
+        :param value: coefficient of constraint entry
+
+        """
+
+        PY_SCIP_CALL( SCIPaddCoefLinear(self._scip, cons.scip_cons, var.scip_var, value) )
+
+    def getActivity(self, Constraint cons, Solution sol = None):
+        """Retrieve activity of given constraint.
+        Can only be called after solving is completed.
+
+        :param Constraint cons: linear or quadratic constraint
+        :param Solution sol: solution to compute activity of, None to use current node's solution (Default value = None)
+
+        """
+        cdef SCIP_Real activity
+        cdef SCIP_SOL* scip_sol
+
+        if not self.getStage() >= SCIP_STAGE_SOLVING:
+            raise Warning("method cannot be called before problem is solved")
+
+        if isinstance(sol, Solution):
+            scip_sol = sol.sol
+        else:
+            scip_sol = NULL
+
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if constype == 'linear':
+            activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol)
+        else:
+            raise Warning("method cannot be called for constraints of type " + constype)
+
+        return activity
+
+
+    def getSlack(self, Constraint cons, Solution sol = None, side = None):
+        """Retrieve slack of given constraint.
+        Can only be called after solving is completed.
+
+
+        :param Constraint cons: linear or quadratic constraint
+        :param Solution sol: solution to compute slack of, None to use current node's solution (Default value = None)
+        :param side: whether to use 'lhs' or 'rhs' for ranged constraints, None to return minimum (Default value = None)
+
+        """
+        cdef SCIP_Real activity
+        cdef SCIP_SOL* scip_sol
+
+
+        if not self.getStage() >= SCIP_STAGE_SOLVING:
+            raise Warning("method cannot be called before problem is solved")
+
+        if isinstance(sol, Solution):
+            scip_sol = sol.sol
+        else:
+            scip_sol = NULL
+
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if constype == 'linear':
+            lhs = SCIPgetLhsLinear(self._scip, cons.scip_cons)
+            rhs = SCIPgetRhsLinear(self._scip, cons.scip_cons)
+            activity = SCIPgetActivityLinear(self._scip, cons.scip_cons, scip_sol)
+        else:
+            raise Warning("method cannot be called for constraints of type " + constype)
+
+        lhsslack = activity - lhs
+        rhsslack = rhs - activity
+
+        if side == 'lhs':
+            return lhsslack
+        elif side == 'rhs':
+            return rhsslack
+        else:
+            return min(lhsslack, rhsslack)
+
+    def getTransformedCons(self, Constraint cons):
+        """Retrieve transformed constraint.
+
+        :param Constraint cons: constraint
+
+        """
+        cdef SCIP_CONS* transcons
+        PY_SCIP_CALL(SCIPgetTransformedCons(self._scip, cons.scip_cons, &transcons))
+        return Constraint.create(transcons)
+
+    def isNLPConstructed(self):
+        """returns whether SCIP's internal NLP has been constructed"""
+        return SCIPisNLPConstructed(self._scip)
+
+    def getNNlRows(self):
+        """gets current number of nonlinear rows in SCIP's internal NLP"""
+        return SCIPgetNNLPNlRows(self._scip)
+
+    def getNlRows(self):
+        """returns a list with the nonlinear rows in SCIP's internal NLP"""
+        cdef SCIP_NLROW** nlrows
+
+        nlrows = SCIPgetNLPNlRows(self._scip)
+        return [NLRow.create(nlrows[i]) for i in range(self.getNNlRows())]
+
+    def getNlRowSolActivity(self, NLRow nlrow, Solution sol = None):
+        """gives the activity of a nonlinear row for a given primal solution
+        Keyword arguments:
+        nlrow -- nonlinear row
+        solution -- a primal solution, if None, then the current LP solution is used
+        """
+        cdef SCIP_Real activity
+        cdef SCIP_SOL* solptr
+
+        solptr = sol.sol if not sol is None else NULL
+        PY_SCIP_CALL( SCIPgetNlRowSolActivity(self._scip, nlrow.scip_nlrow, solptr, &activity) )
+        return activity
+
+    def getNlRowSolFeasibility(self, NLRow nlrow, Solution sol = None):
+        """gives the feasibility of a nonlinear row for a given primal solution
+        Keyword arguments:
+        nlrow -- nonlinear row
+        solution -- a primal solution, if None, then the current LP solution is used
+        """
+        cdef SCIP_Real feasibility
+        cdef SCIP_SOL* solptr
+
+        solptr = sol.sol if not sol is None else NULL
+        PY_SCIP_CALL( SCIPgetNlRowSolFeasibility(self._scip, nlrow.scip_nlrow, solptr, &feasibility) )
+        return feasibility
+
+    def getNlRowActivityBounds(self, NLRow nlrow):
+        """gives the minimal and maximal activity of a nonlinear row w.r.t. the variable's bounds"""
+        cdef SCIP_Real minactivity
+        cdef SCIP_Real maxactivity
+
+        PY_SCIP_CALL( SCIPgetNlRowActivityBounds(self._scip, nlrow.scip_nlrow, &minactivity, &maxactivity) )
+        return (minactivity, maxactivity)
+
+    def printNlRow(self, NLRow nlrow):
+        """prints nonlinear row"""
+        PY_SCIP_CALL( SCIPprintNlRow(self._scip, nlrow.scip_nlrow, NULL) )
+
+    def checkQuadraticNonlinear(self, Constraint cons):
+        """returns if the given constraint is quadratic
+
+        :param Constraint cons: constraint
+
+        """
+        cdef SCIP_Bool isquadratic
+        PY_SCIP_CALL( SCIPcheckQuadraticNonlinear(self._scip, cons.scip_cons, &isquadratic) )
+        return isquadratic
+
+    def getTermsQuadratic(self, Constraint cons):
+        """Retrieve bilinear, quadratic, and linear terms of a quadratic constraint.
+
+        :param Constraint cons: constraint
+
+        """
+        cdef SCIP_EXPR* expr
+
+        # linear terms
+        cdef SCIP_EXPR** _linexprs
+        cdef SCIP_Real* _lincoefs
+        cdef int _nlinvars
+
+        # bilinear terms
+        cdef int _nbilinterms
+        cdef SCIP_EXPR* bilinterm1
+        cdef SCIP_EXPR* bilinterm2
+        cdef SCIP_Real bilincoef
+
+        # quadratic terms
+        cdef int _nquadterms
+        cdef SCIP_Real sqrcoef
+        cdef SCIP_Real lincoef
+        cdef SCIP_EXPR* sqrexpr
+
+        # variables
+        cdef SCIP_VAR* scipvar1
+        cdef SCIP_VAR* scipvar2
+
+        assert cons.isNonlinear(), "constraint is not nonlinear"
+        assert self.checkQuadraticNonlinear(cons), "constraint is not quadratic"
+
+        expr = SCIPgetExprNonlinear(cons.scip_cons)
+        SCIPexprGetQuadraticData(expr, NULL, &_nlinvars, &_linexprs, &_lincoefs, &_nquadterms, &_nbilinterms, NULL, NULL)
+
+        linterms   = []
+        bilinterms = []
+        quadterms  = []
+
+        for termidx in range(_nlinvars):
+            var = Variable.create(SCIPgetVarExprVar(_linexprs[termidx]))
+            linterms.append((var,_lincoefs[termidx]))
+
+        for termidx in range(_nbilinterms):
+            SCIPexprGetQuadraticBilinTerm(expr, termidx, &bilinterm1, &bilinterm2, &bilincoef, NULL, NULL)
+            scipvar1 = SCIPgetVarExprVar(bilinterm1)
+            scipvar2 = SCIPgetVarExprVar(bilinterm2)
+            var1 = Variable.create(scipvar1)
+            var2 = Variable.create(scipvar2)
+            if scipvar1 != scipvar2:
+                bilinterms.append((var1,var2,bilincoef))
+            else:
+                quadterms.append((var1,bilincoef,0.0))
+
+        for termidx in range(_nquadterms):
+            SCIPexprGetQuadraticQuadTerm(expr, termidx, NULL, &lincoef, &sqrcoef, NULL, NULL, &sqrexpr)
+            if sqrexpr == NULL:
+                continue
+            var = Variable.create(SCIPgetVarExprVar(sqrexpr))
+            quadterms.append((var,sqrcoef,lincoef))
+
+        return (bilinterms, quadterms, linterms)
+
+    def setRelaxSolVal(self, Variable var, val):
+        """sets the value of the given variable in the global relaxation solution"""
+        PY_SCIP_CALL(SCIPsetRelaxSolVal(self._scip, NULL, var.scip_var, val))
+
+    def getConss(self, transformed=True):
+        """Retrieve all constraints.
+        
+        :param transformed: get transformed variables instead of original (Default value = True)
+        """
+        cdef SCIP_CONS** _conss
+        cdef int _nconss
+        conss = []
+
+        if transformed:
+            _conss = SCIPgetConss(self._scip)
+            _nconss = SCIPgetNConss(self._scip)
+        else:
+            _conss = SCIPgetOrigConss(self._scip)
+            _nconss = SCIPgetNOrigConss(self._scip)
+        return [Constraint.create(_conss[i]) for i in range(_nconss)]
+
+    def getNConss(self, transformed=True):
+        """Retrieve number of all constraints"""
+        if transformed:
+            return SCIPgetNConss(self._scip)
+        else:
+            return SCIPgetNOrigConss(self._scip)
+
+    def delCons(self, Constraint cons):
+        """Delete constraint from the model
+
+        :param Constraint cons: constraint to be deleted
+
+        """
+        PY_SCIP_CALL(SCIPdelCons(self._scip, cons.scip_cons))
+
+    def delConsLocal(self, Constraint cons):
+        """Delete constraint from the current node and it's children
+
+        :param Constraint cons: constraint to be deleted
+
+        """
+        PY_SCIP_CALL(SCIPdelConsLocal(self._scip, cons.scip_cons))
+
+    def getValsLinear(self, Constraint cons):
+        """Retrieve the coefficients of a linear constraint
+
+        :param Constraint cons: linear constraint to get the coefficients of
+
+        """
+        cdef SCIP_Real* _vals
+        cdef SCIP_VAR** _vars
+
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if not constype == 'linear':
+            raise Warning("coefficients not available for constraints of type ", constype)
+
+        _vals = SCIPgetValsLinear(self._scip, cons.scip_cons)
+        _vars = SCIPgetVarsLinear(self._scip, cons.scip_cons)
+
+        valsdict = {}
+        for i in range(SCIPgetNVarsLinear(self._scip, cons.scip_cons)):
+            valsdict[bytes(SCIPvarGetName(_vars[i])).decode('utf-8')] = _vals[i]
+        return valsdict
+
+    def getRowLinear(self, Constraint cons):
+        """Retrieve the linear relaxation of the given linear constraint as a row.
+           may return NULL if no LP row was yet created; the user must not modify the row!
+
+        :param Constraint cons: linear constraint to get the coefficients of
+
+        """
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if not constype == 'linear':
+            raise Warning("coefficients not available for constraints of type ", constype)
+
+        cdef SCIP_ROW* row = SCIPgetRowLinear(self._scip, cons.scip_cons)
+        return Row.create(row)
+
+    def getDualsolLinear(self, Constraint cons):
+        """Retrieve the dual solution to a linear constraint.
+
+        :param Constraint cons: linear constraint
+
+        """
+        constype = bytes(SCIPconshdlrGetName(SCIPconsGetHdlr(cons.scip_cons))).decode('UTF-8')
+        if not constype == 'linear':
+            raise Warning("dual solution values not available for constraints of type ", constype)
+        if cons.isOriginal():
+            transcons = self.getTransformedCons(cons)
+        else:
+            transcons = cons
+        return SCIPgetDualsolLinear(self._scip, transcons.scip_cons)
+
+    def getDualMultiplier(self, Constraint cons):
+        """DEPRECATED: Retrieve the dual solution to a linear constraint.
+
+        :param Constraint cons: linear constraint
+
+        """
+        raise Warning("model.getDualMultiplier(cons) is deprecated: please use model.getDualsolLinear(cons)")
+        return self.getDualsolLinear(cons)
+
+    def getDualfarkasLinear(self, Constraint cons):
+        """Retrieve the dual farkas value to a linear constraint.
+
+        :param Constraint cons: linear constraint
+
+        """
+        # TODO this should ideally be handled on the SCIP side
+        if cons.isOriginal():
+            transcons = self.getTransformedCons(cons)
+            return SCIPgetDualfarkasLinear(self._scip, transcons.scip_cons)
+        else:
+            return SCIPgetDualfarkasLinear(self._scip, cons.scip_cons)
+
+    def getVarRedcost(self, Variable var):
+        """Retrieve the reduced cost of a variable.
+
+        :param Variable var: variable to get the reduced cost of
+
+        """
+        redcost = None
+        try:
+            redcost = SCIPgetVarRedcost(self._scip, var.scip_var)
+            if self.getObjectiveSense() == "maximize":
+                redcost = -redcost
+        except:
+            raise Warning("no reduced cost available for variable " + var.name)
+        return redcost
+
+    def getDualSolVal(self, Constraint cons, boundconstraint=False):
+        """Retrieve returns dual solution value of a constraint.
+
+        :param Constraint cons: constraint to get the dual solution value of
+        :param boundconstraint bool: Decides whether to store a bool if the constraint is a bound constraint
+
+        """
+        cdef SCIP_Real _dualsol
+        cdef SCIP_Bool _bounded
+
+        if boundconstraint:
+            SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, &_bounded)
+        else:
+            SCIPgetDualSolVal(self._scip, cons.scip_cons, &_dualsol, NULL)
+
+        return _dualsol
+
+    def optimize(self):
+        """Optimize the problem."""
+        PY_SCIP_CALL(SCIPsolve(self._scip))
+        self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip))
+
+    def solveConcurrent(self):
+        """Transforms, presolves, and solves problem using additional solvers which emphasize on
+        finding solutions."""
+        if SCIPtpiGetNumThreads() == 1:
+            warnings.warn("SCIP was compiled without task processing interface. Parallel solve not possible - using optimize() instead of solveConcurrent()") 
+            self.optimize()
+        else:
+            PY_SCIP_CALL(SCIPsolveConcurrent(self._scip))
+            self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip))
+
+    def presolve(self):
+        """Presolve the problem."""
+        PY_SCIP_CALL(SCIPpresolve(self._scip))
+
+    # Benders' decomposition methods
+    def initBendersDefault(self, subproblems):
+        """initialises the default Benders' decomposition with a dictionary of subproblems
+
+        Keyword arguments:
+        subproblems -- a single Model instance or dictionary of Model instances
+        """
+        cdef SCIP** subprobs
+        cdef SCIP_BENDERS* benders
+
+        # checking whether subproblems is a dictionary
+        if isinstance(subproblems, dict):
+            isdict = True
+            nsubproblems = len(subproblems)
+        else:
+            isdict = False
+            nsubproblems = 1
+
+        # create array of SCIP instances for the subproblems
+        subprobs =  malloc(nsubproblems * sizeof(SCIP*))
+
+        # if subproblems is a dictionary, then the dictionary is turned into a c array
+        if isdict:
+            for idx, subprob in enumerate(subproblems.values()):
+                subprobs[idx] = (subprob)._scip
+        else:
+            subprobs[0] = (subproblems)._scip
+
+        # creating the default Benders' decomposition
+        PY_SCIP_CALL(SCIPcreateBendersDefault(self._scip, subprobs, nsubproblems))
+        benders = SCIPfindBenders(self._scip, "default")
+
+        # activating the Benders' decomposition constraint handlers
+        self.setBoolParam("constraints/benderslp/active", True)
+        self.setBoolParam("constraints/benders/active", True)
+        #self.setIntParam("limits/maxorigsol", 0)
+
+    def computeBestSolSubproblems(self):
+        """Solves the subproblems with the best solution to the master problem.
+        Afterwards, the best solution from each subproblem can be queried to get
+        the solution to the original problem.
+
+        If the user wants to resolve the subproblems, they must free them by
+        calling freeBendersSubproblems()
+        """
+        cdef SCIP_BENDERS** _benders
+        cdef SCIP_Bool _infeasible
+        cdef int nbenders
+        cdef int nsubproblems
+
+        solvecip = True
+
+        nbenders = SCIPgetNActiveBenders(self._scip)
+        _benders = SCIPgetBenders(self._scip)
+
+        # solving all subproblems from all Benders' decompositions
+        for i in range(nbenders):
+            nsubproblems = SCIPbendersGetNSubproblems(_benders[i])
+            for j in range(nsubproblems):
+                PY_SCIP_CALL(SCIPsetupBendersSubproblem(self._scip,
+                    _benders[i], self._bestSol.sol, j, SCIP_BENDERSENFOTYPE_CHECK))
+                PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip,
+                    _benders[i], self._bestSol.sol, j, &_infeasible, solvecip, NULL))
+
+    def freeBendersSubproblems(self):
+        """Calls the free subproblem function for the Benders' decomposition.
+        This will free all subproblems for all decompositions.
+        """
+        cdef SCIP_BENDERS** _benders
+        cdef int nbenders
+        cdef int nsubproblems
+
+        nbenders = SCIPgetNActiveBenders(self._scip)
+        _benders = SCIPgetBenders(self._scip)
+
+        # solving all subproblems from all Benders' decompositions
+        for i in range(nbenders):
+            nsubproblems = SCIPbendersGetNSubproblems(_benders[i])
+            for j in range(nsubproblems):
+                PY_SCIP_CALL(SCIPfreeBendersSubproblem(self._scip, _benders[i],
+                    j))
+
+    def updateBendersLowerbounds(self, lowerbounds, Benders benders=None):
+        """"updates the subproblem lower bounds for benders using
+        the lowerbounds dict. If benders is None, then the default
+        Benders' decomposition is updated
+        """
+        cdef SCIP_BENDERS* _benders
+
+        assert type(lowerbounds) is dict
+
+        if benders is None:
+            _benders = SCIPfindBenders(self._scip, "default")
+        else:
+            _benders = benders._benders
+
+        for d in lowerbounds.keys():
+            SCIPbendersUpdateSubproblemLowerbound(_benders, d, lowerbounds[d])
+
+    def activateBenders(self, Benders benders, int nsubproblems):
+        """Activates the Benders' decomposition plugin with the input name
+
+        Keyword arguments:
+        benders -- the Benders' decomposition to which the subproblem belongs to
+        nsubproblems -- the number of subproblems in the Benders' decomposition
+        """
+        PY_SCIP_CALL(SCIPactivateBenders(self._scip, benders._benders, nsubproblems))
+
+    def addBendersSubproblem(self, Benders benders, subproblem):
+        """adds a subproblem to the Benders' decomposition given by the input
+        name.
+
+        Keyword arguments:
+        benders -- the Benders' decomposition to which the subproblem belongs to
+        subproblem --  the subproblem to add to the decomposition
+        isconvex -- can be used to specify whether the subproblem is convex
+        """
+        PY_SCIP_CALL(SCIPaddBendersSubproblem(self._scip, benders._benders, (subproblem)._scip))
+
+    def setBendersSubproblemIsConvex(self, Benders benders, probnumber, isconvex = True):
+        """sets a flag indicating whether the subproblem is convex
+
+        Keyword arguments:
+        benders -- the Benders' decomposition which contains the subproblem
+        probnumber -- the problem number of the subproblem that the convexity will be set for
+        isconvex -- flag to indicate whether the subproblem is convex
+        """
+        SCIPbendersSetSubproblemIsConvex(benders._benders, probnumber, isconvex)
+
+    def setupBendersSubproblem(self, probnumber, Benders benders = None, Solution solution = None, checktype = PY_SCIP_BENDERSENFOTYPE.LP):
+        """ sets up the Benders' subproblem given the master problem solution
+
+        Keyword arguments:
+        probnumber -- the index of the problem that is to be set up
+        benders -- the Benders' decomposition to which the subproblem belongs to
+        solution -- the master problem solution that is used for the set up, if None, then the LP solution is used
+        checktype -- the type of solution check that prompted the solving of the Benders' subproblems, either
+            PY_SCIP_BENDERSENFOTYPE: LP, RELAX, PSEUDO or CHECK. Default is LP
+        """
+        cdef SCIP_BENDERS* scip_benders
+        cdef SCIP_SOL* scip_sol
+
+        if isinstance(solution, Solution):
+            scip_sol = solution.sol
+        else:
+            scip_sol = NULL
+
+        if benders is None:
+            scip_benders = SCIPfindBenders(self._scip, "default")
+        else:
+            scip_benders = benders._benders
+
+        retcode = SCIPsetupBendersSubproblem(self._scip, scip_benders, scip_sol, probnumber, checktype)
+
+        PY_SCIP_CALL(retcode)
+
+    def solveBendersSubproblem(self, probnumber, solvecip, Benders benders = None, Solution solution = None):
+        """ solves the Benders' decomposition subproblem. The convex relaxation will be solved unless
+        the parameter solvecip is set to True.
+
+        Keyword arguments:
+        probnumber -- the index of the problem that is to be set up
+        solvecip -- should the CIP of the subproblem be solved, if False, then only the convex relaxation is solved
+        benders -- the Benders' decomposition to which the subproblem belongs to
+        solution -- the master problem solution that is used for the set up, if None, then the LP solution is used
+        """
+
+        cdef SCIP_BENDERS* scip_benders
+        cdef SCIP_SOL* scip_sol
+        cdef SCIP_Real objective
+        cdef SCIP_Bool infeasible
+
+        if isinstance(solution, Solution):
+            scip_sol = solution.sol
+        else:
+            scip_sol = NULL
+
+        if benders is None:
+            scip_benders = SCIPfindBenders(self._scip, "default")
+        else:
+            scip_benders = benders._benders
+
+        PY_SCIP_CALL(SCIPsolveBendersSubproblem(self._scip, scip_benders, scip_sol,
+            probnumber, &infeasible, solvecip, &objective))
+
+        return infeasible, objective
+
+    def getBendersSubproblem(self, probnumber, Benders benders = None):
+        """Returns a Model object that wraps around the SCIP instance of the subproblem.
+        NOTE: This Model object is just a place holder and SCIP instance will not be freed when the object is destroyed.
+
+        Keyword arguments:
+        probnumber -- the problem number for subproblem that is required
+        benders -- the Benders' decomposition object for the that the subproblem belongs to (Default = None)
+        """
+        cdef SCIP_BENDERS* scip_benders
+        cdef SCIP* scip_subprob
+
+        if benders is None:
+            scip_benders = SCIPfindBenders(self._scip, "default")
+        else:
+            scip_benders = benders._benders
+
+        scip_subprob = SCIPbendersSubproblem(scip_benders, probnumber)
+
+        return Model.create(scip_subprob)
+
+    def getBendersVar(self, Variable var, Benders benders = None, probnumber = -1):
+        """Returns the variable for the subproblem or master problem
+        depending on the input probnumber
+
+        Keyword arguments:
+        var -- the source variable for which the target variable is requested
+        benders -- the Benders' decomposition to which the subproblem variables belong to
+        probnumber -- the problem number for which the target variable belongs, -1 for master problem
+        """
+        cdef SCIP_BENDERS* _benders
+        cdef SCIP_VAR* _mappedvar
+
+        if benders is None:
+            _benders = SCIPfindBenders(self._scip, "default")
+        else:
+            _benders = benders._benders
+
+        if probnumber == -1:
+            PY_SCIP_CALL(SCIPgetBendersMasterVar(self._scip, _benders, var.scip_var, &_mappedvar))
+        else:
+            PY_SCIP_CALL(SCIPgetBendersSubproblemVar(self._scip, _benders, var.scip_var, &_mappedvar, probnumber))
+
+        if _mappedvar == NULL:
+            mappedvar = None
+        else:
+            mappedvar = Variable.create(_mappedvar)
+
+        return mappedvar
+
+    def getBendersAuxiliaryVar(self, probnumber, Benders benders = None):
+        """Returns the auxiliary variable that is associated with the input problem number
+
+        Keyword arguments:
+        probnumber -- the problem number for which the target variable belongs, -1 for master problem
+        benders -- the Benders' decomposition to which the subproblem variables belong to
+        """
+        cdef SCIP_BENDERS* _benders
+        cdef SCIP_VAR* _auxvar
+
+        if benders is None:
+            _benders = SCIPfindBenders(self._scip, "default")
+        else:
+            _benders = benders._benders
+
+        _auxvar = SCIPbendersGetAuxiliaryVar(_benders, probnumber)
+        auxvar = Variable.create(_auxvar)
+
+        return auxvar
+
+    def checkBendersSubproblemOptimality(self, Solution solution, probnumber, Benders benders = None):
+        """Returns whether the subproblem is optimal w.r.t the master problem auxiliary variables.
+
+        Keyword arguments:
+        solution -- the master problem solution that is being checked for optimamlity
+        probnumber -- the problem number for which optimality is being checked
+        benders -- the Benders' decomposition to which the subproblem belongs to
+        """
+        cdef SCIP_BENDERS* _benders
+        cdef SCIP_SOL* scip_sol
+        cdef SCIP_Bool optimal
+
+        if benders is None:
+            _benders = SCIPfindBenders(self._scip, "default")
+        else:
+            _benders = benders._benders
+
+        if isinstance(solution, Solution):
+            scip_sol = solution.sol
+        else:
+            scip_sol = NULL
+
+        PY_SCIP_CALL( SCIPcheckBendersSubproblemOptimality(self._scip, _benders,
+            scip_sol, probnumber, &optimal) )
+
+        return optimal
+
+    def includeBendersDefaultCuts(self, Benders benders):
+        """includes the default Benders' decomposition cuts to the custom Benders' decomposition plugin
+
+        Keyword arguments:
+        benders -- the Benders' decomposition that the default cuts will be applied to
+        """
+        PY_SCIP_CALL( SCIPincludeBendersDefaultCuts(self._scip, benders._benders) )
+
+
+    def includeEventhdlr(self, Eventhdlr eventhdlr, name, desc):
+        """Include an event handler.
+
+        Keyword arguments:
+        eventhdlr -- event handler
+        name -- name of event handler
+        desc -- description of event handler
+        """
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeEventhdlr(self._scip, n, d,
+                                          PyEventCopy,
+                                          PyEventFree,
+                                          PyEventInit,
+                                          PyEventExit,
+                                          PyEventInitsol,
+                                          PyEventExitsol,
+                                          PyEventDelete,
+                                          PyEventExec,
+                                          eventhdlr))
+        eventhdlr.model = weakref.proxy(self)
+        eventhdlr.name = name
+        Py_INCREF(eventhdlr)
+
+    def includePricer(self, Pricer pricer, name, desc, priority=1, delay=True):
+        """Include a pricer.
+
+        :param Pricer pricer: pricer
+        :param name: name of pricer
+        :param desc: description of pricer
+        :param priority: priority of pricer (Default value = 1)
+        :param delay: should the pricer be delayed until no other pricers or already existing problem variables with negative reduced costs are found? (Default value = True)
+
+        """
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludePricer(self._scip, n, d,
+                                            priority, delay,
+                                            PyPricerCopy, PyPricerFree, PyPricerInit, PyPricerExit, PyPricerInitsol, PyPricerExitsol, PyPricerRedcost, PyPricerFarkas,
+                                            pricer))
+        cdef SCIP_PRICER* scip_pricer
+        scip_pricer = SCIPfindPricer(self._scip, n)
+        PY_SCIP_CALL(SCIPactivatePricer(self._scip, scip_pricer))
+        pricer.model = weakref.proxy(self)
+        Py_INCREF(pricer)
+
+    def includeConshdlr(self, Conshdlr conshdlr, name, desc, sepapriority=0,
+                        enfopriority=0, chckpriority=0, sepafreq=-1, propfreq=-1,
+                        eagerfreq=100, maxprerounds=-1, delaysepa=False,
+                        delayprop=False, needscons=True,
+                        proptiming=PY_SCIP_PROPTIMING.BEFORELP,
+                        presoltiming=PY_SCIP_PRESOLTIMING.MEDIUM):
+        """Include a constraint handler
+
+        :param Conshdlr conshdlr: constraint handler
+        :param name: name of constraint handler
+        :param desc: description of constraint handler
+        :param sepapriority: priority for separation (Default value = 0)
+        :param enfopriority: priority for constraint enforcing (Default value = 0)
+        :param chckpriority: priority for checking feasibility (Default value = 0)
+        :param sepafreq: frequency for separating cuts; 0 = only at root node (Default value = -1)
+        :param propfreq: frequency for propagating domains; 0 = only preprocessing propagation (Default value = -1)
+        :param eagerfreq: frequency for using all instead of only the useful constraints in separation, propagation and enforcement; -1 = no eager evaluations, 0 = first only (Default value = 100)
+        :param maxprerounds: maximal number of presolving rounds the constraint handler participates in (Default value = -1)
+        :param delaysepa: should separation method be delayed, if other separators found cuts? (Default value = False)
+        :param delayprop: should propagation method be delayed, if other propagators found reductions? (Default value = False)
+        :param needscons: should the constraint handler be skipped, if no constraints are available? (Default value = True)
+        :param proptiming: positions in the node solving loop where propagation method of constraint handlers should be executed (Default value = SCIP_PROPTIMING.BEFORELP)
+        :param presoltiming: timing mask of the constraint handler's presolving method (Default value = SCIP_PRESOLTIMING.MEDIUM)
+
+        """
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeConshdlr(self._scip, n, d, sepapriority, enfopriority, chckpriority, sepafreq, propfreq, eagerfreq,
+                                              maxprerounds, delaysepa, delayprop, needscons, proptiming, presoltiming,
+                                              PyConshdlrCopy, PyConsFree, PyConsInit, PyConsExit, PyConsInitpre, PyConsExitpre,
+                                              PyConsInitsol, PyConsExitsol, PyConsDelete, PyConsTrans, PyConsInitlp, PyConsSepalp, PyConsSepasol,
+                                              PyConsEnfolp, PyConsEnforelax, PyConsEnfops, PyConsCheck, PyConsProp, PyConsPresol, PyConsResprop, PyConsLock,
+                                              PyConsActive, PyConsDeactive, PyConsEnable, PyConsDisable, PyConsDelvars, PyConsPrint, PyConsCopy,
+                                              PyConsParse, PyConsGetvars, PyConsGetnvars, PyConsGetdivebdchgs, PyConsGetPermSymGraph, PyConsGetSignedPermSymGraph,
+                                              conshdlr))
+        conshdlr.model = weakref.proxy(self)
+        conshdlr.name = name
+        Py_INCREF(conshdlr)
+
+    def createCons(self, Conshdlr conshdlr, name, initial=True, separate=True, enforce=True, check=True, propagate=True,
+                   local=False, modifiable=False, dynamic=False, removable=False, stickingatnode=False):
+        """Create a constraint of a custom constraint handler
+
+        :param Conshdlr conshdlr: constraint handler
+        :param name: name of constraint
+        :param initial:  (Default value = True)
+        :param separate:  (Default value = True)
+        :param enforce:  (Default value = True)
+        :param check:  (Default value = True)
+        :param propagate:  (Default value = True)
+        :param local:  (Default value = False)
+        :param modifiable:  (Default value = False)
+        :param dynamic:  (Default value = False)
+        :param removable:  (Default value = False)
+        :param stickingatnode:  (Default value = False)
+
+        """
+
+        n = str_conversion(name)
+        cdef SCIP_CONSHDLR* scip_conshdlr
+        scip_conshdlr = SCIPfindConshdlr(self._scip, str_conversion(conshdlr.name))
+        constraint = Constraint()
+        PY_SCIP_CALL(SCIPcreateCons(self._scip, &(constraint.scip_cons), n, scip_conshdlr, constraint,
+                                initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode))
+        return constraint
+
+    def includePresol(self, Presol presol, name, desc, priority, maxrounds, timing=SCIP_PRESOLTIMING_FAST):
+        """Include a presolver
+
+        :param Presol presol: presolver
+        :param name: name of presolver
+        :param desc: description of presolver
+        :param priority: priority of the presolver (>= 0: before, < 0: after constraint handlers)
+        :param maxrounds: maximal number of presolving rounds the presolver participates in (-1: no limit)
+        :param timing: timing mask of presolver (Default value = SCIP_PRESOLTIMING_FAST)
+
+        """
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludePresol(self._scip, n, d, priority, maxrounds, timing, PyPresolCopy, PyPresolFree, PyPresolInit,
+                                            PyPresolExit, PyPresolInitpre, PyPresolExitpre, PyPresolExec, presol))
+        presol.model = weakref.proxy(self)
+        Py_INCREF(presol)
+
+    def includeSepa(self, Sepa sepa, name, desc, priority=0, freq=10, maxbounddist=1.0, usessubscip=False, delay=False):
+        """Include a separator
+
+        :param Sepa sepa: separator
+        :param name: name of separator
+        :param desc: description of separator
+        :param priority: priority of separator (>= 0: before, < 0: after constraint handlers)
+        :param freq: frequency for calling separator
+        :param maxbounddist: maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying separation
+        :param usessubscip: does the separator use a secondary SCIP instance? (Default value = False)
+        :param delay: should separator be delayed, if other separators found cuts? (Default value = False)
+
+        """
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeSepa(self._scip, n, d, priority, freq, maxbounddist, usessubscip, delay, PySepaCopy, PySepaFree,
+                                          PySepaInit, PySepaExit, PySepaInitsol, PySepaExitsol, PySepaExeclp, PySepaExecsol, sepa))
+        sepa.model = weakref.proxy(self)
+        sepa.name = name
+        Py_INCREF(sepa)
+
+    def includeReader(self, Reader reader, name, desc, ext):
+        """Include a reader
+
+        :param Reader reader: reader
+        :param name: name of reader
+        :param desc: description of reader
+        :param ext: file extension of reader
+
+        """
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        e = str_conversion(ext)
+        PY_SCIP_CALL(SCIPincludeReader(self._scip, n, d, e, PyReaderCopy, PyReaderFree,
+                                          PyReaderRead, PyReaderWrite, reader))
+        reader.model = weakref.proxy(self)
+        reader.name = name
+        Py_INCREF(reader)
+
+    def includeProp(self, Prop prop, name, desc, presolpriority, presolmaxrounds,
+                    proptiming, presoltiming=SCIP_PRESOLTIMING_FAST, priority=1, freq=1, delay=True):
+        """Include a propagator.
+
+        :param Prop prop: propagator
+        :param name: name of propagator
+        :param desc: description of propagator
+        :param presolpriority: presolving priority of the propgator (>= 0: before, < 0: after constraint handlers)
+        :param presolmaxrounds: maximal number of presolving rounds the propagator participates in (-1: no limit)
+        :param proptiming: positions in the node solving loop where propagation method of constraint handlers should be executed
+        :param presoltiming: timing mask of the constraint handler's presolving method (Default value = SCIP_PRESOLTIMING_FAST)
+        :param priority: priority of the propagator (Default value = 1)
+        :param freq: frequency for calling propagator (Default value = 1)
+        :param delay: should propagator be delayed if other propagators have found reductions? (Default value = True)
+
+        """
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeProp(self._scip, n, d,
+                                          priority, freq, delay,
+                                          proptiming, presolpriority, presolmaxrounds,
+                                          presoltiming, PyPropCopy, PyPropFree, PyPropInit, PyPropExit,
+                                          PyPropInitpre, PyPropExitpre, PyPropInitsol, PyPropExitsol,
+                                          PyPropPresol, PyPropExec, PyPropResProp,
+                                           prop))
+        prop.model = weakref.proxy(self)
+        Py_INCREF(prop)
+
+    def includeHeur(self, Heur heur, name, desc, dispchar, priority=10000, freq=1, freqofs=0,
+                    maxdepth=-1, timingmask=SCIP_HEURTIMING_BEFORENODE, usessubscip=False):
+        """Include a primal heuristic.
+
+        :param Heur heur: heuristic
+        :param name: name of heuristic
+        :param desc: description of heuristic
+        :param dispchar: display character of heuristic
+        :param priority: priority of the heuristic (Default value = 10000)
+        :param freq: frequency for calling heuristic (Default value = 1)
+        :param freqofs: frequency offset for calling heuristic (Default value = 0)
+        :param maxdepth: maximal depth level to call heuristic at (Default value = -1)
+        :param timingmask: positions in the node solving loop where heuristic should be executed (Default value = SCIP_HEURTIMING_BEFORENODE)
+        :param usessubscip: does the heuristic use a secondary SCIP instance? (Default value = False)
+
+        """
+        nam = str_conversion(name)
+        des = str_conversion(desc)
+        dis = ord(str_conversion(dispchar))
+        PY_SCIP_CALL(SCIPincludeHeur(self._scip, nam, des, dis,
+                                          priority, freq, freqofs,
+                                          maxdepth, timingmask, usessubscip,
+                                          PyHeurCopy, PyHeurFree, PyHeurInit, PyHeurExit,
+                                          PyHeurInitsol, PyHeurExitsol, PyHeurExec,
+                                           heur))
+        heur.model = weakref.proxy(self)
+        heur.name = name
+        Py_INCREF(heur)
+
+    def includeRelax(self, Relax relax, name, desc, priority=10000, freq=1):
+        """Include a relaxation handler.
+
+        :param Relax relax: relaxation handler
+        :param name: name of relaxation handler
+        :param desc: description of relaxation handler
+        :param priority: priority of the relaxation handler (negative: after LP, non-negative: before LP, Default value = 10000)
+        :param freq: frequency for calling relaxation handler
+
+        """
+        nam = str_conversion(name)
+        des = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeRelax(self._scip, nam, des, priority, freq, PyRelaxCopy, PyRelaxFree, PyRelaxInit, PyRelaxExit,
+                                          PyRelaxInitsol, PyRelaxExitsol, PyRelaxExec,  relax))
+        relax.model = weakref.proxy(self)
+        relax.name = name
+
+        Py_INCREF(relax)
+
+    def includeCutsel(self, Cutsel cutsel, name, desc, priority):
+        """include a cut selector
+
+        :param Cutsel cutsel: cut selector
+        :param name: name of cut selector
+        :param desc: description of cut selector
+        :param priority: priority of the cut selector
+        """
+
+        nam = str_conversion(name)
+        des = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeCutsel(self._scip, nam, des,
+                                       priority, PyCutselCopy, PyCutselFree, PyCutselInit, PyCutselExit,
+                                       PyCutselInitsol, PyCutselExitsol, PyCutselSelect,
+                                        cutsel))
+        cutsel.model = weakref.proxy(self)
+        Py_INCREF(cutsel)
+
+    def includeBranchrule(self, Branchrule branchrule, name, desc, priority, maxdepth, maxbounddist):
+        """Include a branching rule.
+
+        :param Branchrule branchrule: branching rule
+        :param name: name of branching rule
+        :param desc: description of branching rule
+        :param priority: priority of branching rule
+        :param maxdepth: maximal depth level up to which this branching rule should be used (or -1)
+        :param maxbounddist: maximal relative distance from current node's dual bound to primal bound compared to best node's dual bound for applying branching rule (0.0: only on current best node, 1.0: on all nodes)
+
+        """
+        nam = str_conversion(name)
+        des = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeBranchrule(self._scip, nam, des,
+                                          priority, maxdepth, maxbounddist,
+                                          PyBranchruleCopy, PyBranchruleFree, PyBranchruleInit, PyBranchruleExit,
+                                          PyBranchruleInitsol, PyBranchruleExitsol, PyBranchruleExeclp, PyBranchruleExecext,
+                                          PyBranchruleExecps,  branchrule))
+        branchrule.model = weakref.proxy(self)
+        Py_INCREF(branchrule)
+
+    def includeNodesel(self, Nodesel nodesel, name, desc, stdpriority, memsavepriority):
+        """Include a node selector.
+
+        :param Nodesel nodesel: node selector
+        :param name: name of node selector
+        :param desc: description of node selector
+        :param stdpriority: priority of the node selector in standard mode
+        :param memsavepriority: priority of the node selector in memory saving mode
+
+        """
+        nam = str_conversion(name)
+        des = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeNodesel(self._scip, nam, des,
+                                          stdpriority, memsavepriority,
+                                          PyNodeselCopy, PyNodeselFree, PyNodeselInit, PyNodeselExit,
+                                          PyNodeselInitsol, PyNodeselExitsol, PyNodeselSelect, PyNodeselComp,
+                                           nodesel))
+        nodesel.model = weakref.proxy(self)
+        Py_INCREF(nodesel)
+
+    def includeBenders(self, Benders benders, name, desc, priority=1, cutlp=True, cutpseudo=True, cutrelax=True,
+            shareaux=False):
+        """Include a Benders' decomposition.
+
+        Keyword arguments:
+        benders -- the Benders decomposition
+        name -- the name
+        desc -- the description
+        priority -- priority of the Benders' decomposition
+        cutlp -- should Benders' cuts be generated from LP solutions
+        cutpseudo -- should Benders' cuts be generated from pseudo solutions
+        cutrelax -- should Benders' cuts be generated from relaxation solutions
+        shareaux -- should the Benders' decomposition share the auxiliary variables of the highest priority Benders' decomposition
+        """
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeBenders(self._scip, n, d,
+                                            priority, cutlp, cutrelax, cutpseudo, shareaux,
+                                            PyBendersCopy, PyBendersFree, PyBendersInit, PyBendersExit, PyBendersInitpre,
+                                            PyBendersExitpre, PyBendersInitsol, PyBendersExitsol, PyBendersGetvar,
+                                            PyBendersCreatesub, PyBendersPresubsolve, PyBendersSolvesubconvex,
+                                            PyBendersSolvesub, PyBendersPostsolve, PyBendersFreesub,
+                                            benders))
+        cdef SCIP_BENDERS* scip_benders
+        scip_benders = SCIPfindBenders(self._scip, n)
+        benders.model = weakref.proxy(self)
+        benders.name = name
+        benders._benders = scip_benders
+        Py_INCREF(benders)
+
+    def includeBenderscut(self, Benders benders, Benderscut benderscut, name, desc, priority=1, islpcut=True):
+        """ Include a Benders' decomposition cutting method
+
+        Keyword arguments:
+        benders -- the Benders' decomposition that this cutting method is attached to
+        benderscut --- the Benders' decomposition cutting method
+        name -- the name
+        desc -- the description
+        priority -- priority of the Benders' decomposition
+        islpcut -- is this cutting method suitable for generating cuts for convex relaxations?
+        """
+        cdef SCIP_BENDERS* _benders
+
+        _benders = benders._benders
+
+        n = str_conversion(name)
+        d = str_conversion(desc)
+        PY_SCIP_CALL(SCIPincludeBenderscut(self._scip, _benders, n, d, priority, islpcut,
+                                            PyBenderscutCopy, PyBenderscutFree, PyBenderscutInit, PyBenderscutExit,
+                                            PyBenderscutInitsol, PyBenderscutExitsol, PyBenderscutExec,
+                                            benderscut))
+
+        cdef SCIP_BENDERSCUT* scip_benderscut
+        scip_benderscut = SCIPfindBenderscut(_benders, n)
+        benderscut.model = weakref.proxy(self)
+        benderscut.benders = benders
+        benderscut.name = name
+        # TODO: It might be necessary in increment the reference to benders i.e Py_INCREF(benders)
+        Py_INCREF(benderscut)
+
+
+    def getLPBranchCands(self):
+        """gets branching candidates for LP solution branching (fractional variables) along with solution values,
+        fractionalities, and number of branching candidates; The number of branching candidates does NOT account
+        for fractional implicit integer variables which should not be used for branching decisions. Fractional
+        implicit integer variables are stored at the positions *nlpcands to *nlpcands + *nfracimplvars - 1
+        branching rules should always select the branching candidate among the first npriolpcands of the candidate list
+
+        :return tuple (lpcands, lpcandssol, lpcadsfrac, nlpcands, npriolpcands, nfracimplvars) where
+
+            lpcands: list of variables of LP branching candidates
+            lpcandssol: list of LP candidate solution values
+            lpcandsfrac	list of LP candidate fractionalities
+            nlpcands:    number of LP branching candidates
+            npriolpcands: number of candidates with maximal priority
+            nfracimplvars: number of fractional implicit integer variables
+
+        """
+        cdef int ncands
+        cdef int nlpcands
+        cdef int npriolpcands
+        cdef int nfracimplvars
+
+        cdef SCIP_VAR** lpcands
+        cdef SCIP_Real* lpcandssol
+        cdef SCIP_Real* lpcandsfrac
+
+        PY_SCIP_CALL(SCIPgetLPBranchCands(self._scip, &lpcands, &lpcandssol, &lpcandsfrac,
+                                          &nlpcands, &npriolpcands, &nfracimplvars))
+
+        return ([Variable.create(lpcands[i]) for i in range(nlpcands)], [lpcandssol[i] for i in range(nlpcands)],
+                [lpcandsfrac[i] for i in range(nlpcands)], nlpcands, npriolpcands, nfracimplvars)
+
+    def getPseudoBranchCands(self):
+        """gets branching candidates for pseudo solution branching (non-fixed variables)
+        along with the number of candidates.
+
+        :return tuple (pseudocands, npseudocands, npriopseudocands) where
+
+            pseudocands: list of variables of pseudo branching candidates
+            npseudocands: number of pseudo branching candidates
+            npriopseudocands: number of candidates with maximal priority
+
+        """
+        cdef int npseudocands
+        cdef int npriopseudocands
+
+        cdef SCIP_VAR** pseudocands
+
+        PY_SCIP_CALL(SCIPgetPseudoBranchCands(self._scip, &pseudocands, &npseudocands, &npriopseudocands))
+
+        return ([Variable.create(pseudocands[i]) for i in range(npseudocands)], npseudocands, npriopseudocands)
+
+    def branchVar(self, Variable variable):
+        """Branch on a non-continuous variable.
+
+        :param variable: Variable to branch on
+        :return: tuple(downchild, eqchild, upchild) of Nodes of the left, middle and right child. Middle child only exists
+                    if branch variable is integer (it is None otherwise)
+
+        """
+        cdef SCIP_NODE* downchild
+        cdef SCIP_NODE* eqchild
+        cdef SCIP_NODE* upchild
+
+        PY_SCIP_CALL(SCIPbranchVar(self._scip, (variable).scip_var, &downchild, &eqchild, &upchild))
+        return Node.create(downchild), Node.create(eqchild), Node.create(upchild)
+
+
+    def branchVarVal(self, variable, value):
+        """Branches on variable using a value which separates the domain of the variable.
+
+        :param variable: Variable to branch on
+        :param value: float, value to branch on
+        :return: tuple(downchild, eqchild, upchild) of Nodes of the left, middle and right child. Middle child only exists
+                    if branch variable is integer (it is None otherwise)
+
+        """
+        cdef SCIP_NODE* downchild
+        cdef SCIP_NODE* eqchild
+        cdef SCIP_NODE* upchild
+
+        PY_SCIP_CALL(SCIPbranchVarVal(self._scip, (variable).scip_var, value, &downchild, &eqchild, &upchild))
+
+        return Node.create(downchild), Node.create(eqchild), Node.create(upchild)
+
+    def calcNodeselPriority(self, Variable variable, branchdir, targetvalue):
+        """calculates the node selection priority for moving the given variable's LP value
+        to the given target value;
+        this node selection priority can be given to the SCIPcreateChild() call
+
+        :param variable: variable on which the branching is applied
+        :param branchdir: type of branching that was performed
+        :param targetvalue: new value of the variable in the child node
+        :return: node selection priority for moving the given variable's LP value to the given target value
+
+        """
+        return SCIPcalcNodeselPriority(self._scip, variable.scip_var, branchdir, targetvalue)
+
+    def calcChildEstimate(self, Variable variable, targetvalue):
+        """Calculates an estimate for the objective of the best feasible solution
+        contained in the subtree after applying the given branching;
+        this estimate can be given to the SCIPcreateChild() call
+
+        :param variable: Variable to compute the estimate for
+        :param targetvalue: new value of the variable in the child node
+        :return: objective estimate of the best solution in the subtree after applying the given branching
+
+        """
+        return SCIPcalcChildEstimate(self._scip, variable.scip_var, targetvalue)
+
+    def createChild(self, nodeselprio, estimate):
+        """Create a child node of the focus node.
+
+        :param nodeselprio: float, node selection priority of new node
+        :param estimate: float, estimate for(transformed) objective value of best feasible solution in subtree
+        :return: Node, the child which was created
+
+        """
+        cdef SCIP_NODE* child
+        PY_SCIP_CALL(SCIPcreateChild(self._scip, &child, nodeselprio, estimate))
+        return Node.create(child)
+
+    # Diving methods (Diving is LP related)
+    def startDive(self):
+        """Initiates LP diving
+        It allows the user to change the LP in several ways, solve, change again, etc, without affecting the actual LP that has. When endDive() is called,
+        SCIP will undo all changes done and recover the LP it had before startDive
+        """
+        PY_SCIP_CALL(SCIPstartDive(self._scip))
+
+    def endDive(self):
+        """Quits probing and resets bounds and constraints to the focus node's environment"""
+        PY_SCIP_CALL(SCIPendDive(self._scip))
+
+    def chgVarObjDive(self, Variable var, newobj):
+        """changes (column) variable's objective value in current dive"""
+        PY_SCIP_CALL(SCIPchgVarObjDive(self._scip, var.scip_var, newobj))
+
+    def chgVarLbDive(self, Variable var, newbound):
+        """changes variable's current lb in current dive"""
+        PY_SCIP_CALL(SCIPchgVarLbDive(self._scip, var.scip_var, newbound))
+
+    def chgVarUbDive(self, Variable var, newbound):
+        """changes variable's current ub in current dive"""
+        PY_SCIP_CALL(SCIPchgVarUbDive(self._scip, var.scip_var, newbound))
+
+    def getVarLbDive(self, Variable var):
+        """returns variable's current lb in current dive"""
+        return SCIPgetVarLbDive(self._scip, var.scip_var)
+
+    def getVarUbDive(self, Variable var):
+        """returns variable's current ub in current dive"""
+        return SCIPgetVarUbDive(self._scip, var.scip_var)
+
+    def chgRowLhsDive(self, Row row, newlhs):
+        """changes row lhs in current dive, change will be undone after diving
+        ends, for permanent changes use SCIPchgRowLhs()
+        """
+        PY_SCIP_CALL(SCIPchgRowLhsDive(self._scip, row.scip_row, newlhs))
+
+    def chgRowRhsDive(self, Row row, newrhs):
+        """changes row rhs in current dive, change will be undone after diving
+        ends, for permanent changes use SCIPchgRowLhs()
+        """
+        PY_SCIP_CALL(SCIPchgRowRhsDive(self._scip, row.scip_row, newrhs))
+
+    def addRowDive(self, Row row):
+        """adds a row to the LP in current dive"""
+        PY_SCIP_CALL(SCIPaddRowDive(self._scip, row.scip_row))
+
+    def solveDiveLP(self, itlim = -1):
+        """solves the LP of the current dive no separation or pricing is applied
+        no separation or pricing is applied
+        :param itlim: maximal number of LP iterations to perform (Default value = -1, that is, no limit)
+        returns two booleans:
+        lperror -- if an unresolved lp error occured
+        cutoff -- whether the LP was infeasible or the objective limit was reached
+        """
+        cdef SCIP_Bool lperror
+        cdef SCIP_Bool cutoff
+
+        PY_SCIP_CALL(SCIPsolveDiveLP(self._scip, itlim, &lperror, &cutoff))
+        return lperror, cutoff
+
+    def inRepropagation(self):
+        """returns if the current node is already solved and only propagated again."""
+        return SCIPinRepropagation(self._scip)
+
+    # Probing methods (Probing is tree based)
+    def startProbing(self):
+        """Initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),
+           SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), SCIPsolveProbingLP(), etc available
+        """
+        PY_SCIP_CALL( SCIPstartProbing(self._scip) )
+
+    def endProbing(self):
+        """Quits probing and resets bounds and constraints to the focus node's environment"""
+        PY_SCIP_CALL( SCIPendProbing(self._scip) )
+
+    def newProbingNode(self):
+        """creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the
+        probing path with a call to backtrackProbing()
+        """
+        PY_SCIP_CALL( SCIPnewProbingNode(self._scip) )
+
+    def backtrackProbing(self, probingdepth):
+        """undoes all changes to the problem applied in probing up to the given probing depth
+        :param probingdepth: probing depth of the node in the probing path that should be reactivated
+        """
+        PY_SCIP_CALL( SCIPbacktrackProbing(self._scip, probingdepth) )
+
+    def getProbingDepth(self):
+        """returns the current probing depth"""
+        return SCIPgetProbingDepth(self._scip)
+
+    def chgVarObjProbing(self, Variable var, newobj):
+        """changes (column) variable's objective value during probing mode"""
+        PY_SCIP_CALL( SCIPchgVarObjProbing(self._scip, var.scip_var, newobj) )
+
+    def chgVarLbProbing(self, Variable var, lb):
+        """changes the variable lower bound during probing mode
+
+        :param Variable var: variable to change bound of
+        :param lb: new lower bound (set to None for -infinity)
+        """
+        if lb is None:
+           lb = -SCIPinfinity(self._scip)
+        PY_SCIP_CALL(SCIPchgVarLbProbing(self._scip, var.scip_var, lb))
+
+    def chgVarUbProbing(self, Variable var, ub):
+        """changes the variable upper bound during probing mode
+
+        :param Variable var: variable to change bound of
+        :param ub: new upper bound (set to None for +infinity)
+        """
+        if ub is None:
+           ub = SCIPinfinity(self._scip)
+        PY_SCIP_CALL(SCIPchgVarUbProbing(self._scip, var.scip_var, ub))
+
+    def fixVarProbing(self, Variable var, fixedval):
+        """Fixes a variable at the current probing node."""
+        PY_SCIP_CALL( SCIPfixVarProbing(self._scip, var.scip_var, fixedval) )
+
+    def isObjChangedProbing(self):
+        """returns whether the objective function has changed during probing mode"""
+        return SCIPisObjChangedProbing(self._scip)
+
+    def inProbing(self):
+        """returns whether we are in probing mode; probing mode is activated via startProbing() and stopped via endProbing()"""
+        return SCIPinProbing(self._scip)
+
+    def solveProbingLP(self, itlim = -1):
+        """solves the LP at the current probing node (cannot be applied at preprocessing stage)
+        no separation or pricing is applied
+        :param itlim: maximal number of LP iterations to perform (Default value = -1, that is, no limit)
+        returns two booleans:
+        lperror -- if an unresolved lp error occured
+        cutoff -- whether the LP was infeasible or the objective limit was reached
+        """
+        cdef SCIP_Bool lperror
+        cdef SCIP_Bool cutoff
+
+        PY_SCIP_CALL( SCIPsolveProbingLP(self._scip, itlim, &lperror, &cutoff) )
+        return lperror, cutoff
+
+    def applyCutsProbing(self):
+        """applies the cuts in the separation storage to the LP and clears the storage afterwards;
+        this method can only be applied during probing; the user should resolve the probing LP afterwards
+        in order to get a new solution
+        returns:
+        cutoff -- whether an empty domain was created
+        """
+        cdef SCIP_Bool cutoff
+
+        PY_SCIP_CALL( SCIPapplyCutsProbing(self._scip, &cutoff) )
+        return cutoff
+
+    def propagateProbing(self, maxproprounds):
+        """applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
+        the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
+        and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
+        bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
+        :param maxproprounds: maximal number of propagation rounds (Default value = -1, that is, no limit)
+        returns:
+        cutoff -- whether the probing node can be cutoff
+        ndomredsfound -- number of domain reductions found
+        """
+        cdef SCIP_Bool cutoff
+        cdef SCIP_Longint ndomredsfound
+
+        PY_SCIP_CALL( SCIPpropagateProbing(self._scip, maxproprounds, &cutoff, &ndomredsfound) )
+        return cutoff, ndomredsfound
+
+    def interruptSolve(self):
+        """Interrupt the solving process as soon as possible."""
+        PY_SCIP_CALL(SCIPinterruptSolve(self._scip))
+
+    def restartSolve(self):
+        """Restarts the solving process as soon as possible."""
+        PY_SCIP_CALL(SCIPrestartSolve(self._scip))
+
+    # Solution functions
+
+    def writeLP(self, filename="LP.lp"):
+        """writes current LP to a file
+        :param filename: file name (Default value = "LP.lp")
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        absfile = str_conversion(abspath(filename))
+        PY_SCIP_CALL( SCIPwriteLP(self._scip, absfile) )
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def createSol(self, Heur heur = None):
+        """Create a new primal solution in the transformed space.
+
+        :param Heur heur: heuristic that found the solution (Default value = None)
+
+        """
+        cdef SCIP_HEUR* _heur
+        cdef SCIP_SOL* _sol
+
+        if isinstance(heur, Heur):
+            n = str_conversion(heur.name)
+            _heur = SCIPfindHeur(self._scip, n)
+        else:
+            _heur = NULL
+        PY_SCIP_CALL(SCIPcreateSol(self._scip, &_sol, _heur))
+        solution = Solution.create(self._scip, _sol)
+        return solution
+
+    def createPartialSol(self, Heur heur = None):
+        """Create a partial primal solution, initialized to unknown values.
+        :param Heur heur: heuristic that found the solution (Default value = None)
+
+        """
+        cdef SCIP_HEUR* _heur
+        cdef SCIP_SOL* _sol
+
+        if isinstance(heur, Heur):
+            n = str_conversion(heur.name)
+            _heur = SCIPfindHeur(self._scip, n)
+        else:
+            _heur = NULL
+        PY_SCIP_CALL(SCIPcreatePartialSol(self._scip, &_sol, _heur))
+        partialsolution = Solution.create(self._scip, _sol)
+        return partialsolution
+
+    def createOrigSol(self, Heur heur = None):
+        """Create a new primal solution in the original space.
+
+        :param Heur heur: heuristic that found the solution (Default value = None)
+
+        """
+        cdef SCIP_HEUR* _heur
+        cdef SCIP_SOL* _sol
+
+        if isinstance(heur, Heur):
+            n = str_conversion(heur.name)
+            _heur = SCIPfindHeur(self._scip, n)
+        else:
+            _heur = NULL
+            
+        PY_SCIP_CALL(SCIPcreateOrigSol(self._scip, &_sol, _heur))
+        solution = Solution.create(self._scip, _sol)
+        return solution
+
+    def printBestSol(self, write_zeros=False):
+        """Prints the best feasible primal solution."""
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        PY_SCIP_CALL(SCIPprintBestSol(self._scip, NULL, write_zeros))
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def printSol(self, Solution solution=None, write_zeros=False):
+        """Print the given primal solution.
+
+        Keyword arguments:
+        solution -- solution to print
+        write_zeros -- include variables that are set to zero
+        """
+
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        if solution is None:
+            PY_SCIP_CALL(SCIPprintSol(self._scip, NULL, NULL, write_zeros))
+        else:
+            PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, NULL, write_zeros))
+        
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def writeBestSol(self, filename="origprob.sol", write_zeros=False):
+        """Write the best feasible primal solution to a file.
+
+        Keyword arguments:
+        filename -- name of the output file
+        write_zeros -- include variables that are set to zero
+        """
+
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        # use this doubled opening pattern to ensure that IOErrors are
+        #   triggered early and in Python not in C,Cython or SCIP.
+        with open(filename, "w") as f:
+            cfile = fdopen(f.fileno(), "w")
+            PY_SCIP_CALL(SCIPprintBestSol(self._scip, cfile, write_zeros))
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def writeBestTransSol(self, filename="transprob.sol", write_zeros=False):
+        """Write the best feasible primal solution for the transformed problem to a file.
+
+        Keyword arguments:
+        filename -- name of the output file
+        write_zeros -- include variables that are set to zero
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        # use this double opening pattern to ensure that IOErrors are
+        #   triggered early and in python not in C, Cython or SCIP.
+        with open(filename, "w") as f:
+            cfile = fdopen(f.fileno(), "w")
+            PY_SCIP_CALL(SCIPprintBestTransSol(self._scip, cfile, write_zeros))
+        
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def writeSol(self, Solution solution, filename="origprob.sol", write_zeros=False):
+        """Write the given primal solution to a file.
+
+        Keyword arguments:
+        solution -- solution to write
+        filename -- name of the output file
+        write_zeros -- include variables that are set to zero
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        # use this doubled opening pattern to ensure that IOErrors are
+        #   triggered early and in Python not in C,Cython or SCIP.
+        with open(filename, "w") as f:
+            cfile = fdopen(f.fileno(), "w")
+            PY_SCIP_CALL(SCIPprintSol(self._scip, solution.sol, cfile, write_zeros))
+        
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def writeTransSol(self, Solution solution, filename="transprob.sol", write_zeros=False):
+        """Write the given transformed primal solution to a file.
+
+        Keyword arguments:
+        solution -- transformed solution to write
+        filename -- name of the output file
+        write_zeros -- include variables that are set to zero
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        # use this doubled opening pattern to ensure that IOErrors are
+        #   triggered early and in Python not in C,Cython or SCIP.
+        with open(filename, "w") as f:
+            cfile = fdopen(f.fileno(), "w")
+            PY_SCIP_CALL(SCIPprintTransSol(self._scip, solution.sol, cfile, write_zeros))
+        
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    # perhaps this should not be included as it implements duplicated functionality
+    #   (as does it's namesake in SCIP)
+    def readSol(self, filename):
+        """Reads a given solution file, problem has to be transformed in advance.
+
+        Keyword arguments:
+        filename -- name of the input file
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        absfile = str_conversion(abspath(filename))
+        PY_SCIP_CALL(SCIPreadSol(self._scip, absfile))
+
+        locale.setlocale(locale.LC_NUMERIC, user_locale)
+
+    def readSolFile(self, filename):
+        """Reads a given solution file.
+
+        Solution is created but not added to storage/the model.
+        Use 'addSol' OR 'trySol' to add it.
+
+        Keyword arguments:
+        filename -- name of the input file
+        """
+        cdef SCIP_Bool partial
+        cdef SCIP_Bool error
+        cdef SCIP_Bool stored
+        cdef Solution solution
+
+        str_absfile = abspath(filename)
+        absfile = str_conversion(str_absfile)
+        solution = self.createSol()
+
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        PY_SCIP_CALL(SCIPreadSolFile(self._scip, absfile, solution.sol, False, &partial, &error))
+
+        locale.setlocale(locale.LC_NUMERIC, user_locale)
+
+        if error:
+            raise Exception("SCIP: reading solution from file " + str_absfile + " failed!")
+
+        return solution
+
+    def setSolVal(self, Solution solution, Variable var, val):
+        """Set a variable in a solution.
+
+        :param Solution solution: solution to be modified
+        :param Variable var: variable in the solution
+        :param val: value of the specified variable
+
+        """
+        cdef SCIP_SOL* _sol
+        _sol = solution.sol
+        
+        assert _sol != NULL, "Cannot set value to a freed solution."
+        PY_SCIP_CALL(SCIPsetSolVal(self._scip, _sol, var.scip_var, val))
+
+    def trySol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, free=True):
+        """Check given primal solution for feasibility and try to add it to the storage.
+
+        :param Solution solution: solution to store
+        :param printreason: should all reasons of violations be printed? (Default value = True)
+        :param completely: should all violation be checked? (Default value = False)
+        :param checkbounds: should the bounds of the variables be checked? (Default value = True)
+        :param checkintegrality: has integrality to be checked? (Default value = True)
+        :param checklprows: have current LP rows (both local and global) to be checked? (Default value = True)
+        :param free: should solution be freed? (Default value = True)
+
+        """
+        cdef SCIP_Bool stored
+        if free:
+            PY_SCIP_CALL(SCIPtrySolFree(self._scip, &solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored))
+        else:
+            PY_SCIP_CALL(SCIPtrySol(self._scip, solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &stored))
+        return stored
+
+    def checkSol(self, Solution solution, printreason=True, completely=False, checkbounds=True, checkintegrality=True, checklprows=True, original=False):
+        """Check given primal solution for feasibility without adding it to the storage.
+
+        :param Solution solution: solution to store
+        :param printreason: should all reasons of violations be printed? (Default value = True)
+        :param completely: should all violation be checked? (Default value = False)
+        :param checkbounds: should the bounds of the variables be checked? (Default value = True)
+        :param checkintegrality: has integrality to be checked? (Default value = True)
+        :param checklprows: have current LP rows (both local and global) to be checked? (Default value = True)
+        :param original: must the solution be checked against the original problem (Default value = False)
+
+        """
+        cdef SCIP_Bool feasible
+        if original:
+            PY_SCIP_CALL(SCIPcheckSolOrig(self._scip, solution.sol, &feasible, printreason, completely))
+        else:
+            PY_SCIP_CALL(SCIPcheckSol(self._scip, solution.sol, printreason, completely, checkbounds, checkintegrality, checklprows, &feasible))
+        return feasible
+
+    def addSol(self, Solution solution, free=True):
+        """Try to add a solution to the storage.
+
+        :param Solution solution: solution to store
+        :param free: should solution be freed afterwards? (Default value = True)
+
+        """
+        cdef SCIP_Bool stored
+        if free:
+            PY_SCIP_CALL(SCIPaddSolFree(self._scip, &solution.sol, &stored))
+        else:
+            PY_SCIP_CALL(SCIPaddSol(self._scip, solution.sol, &stored))
+        return stored
+
+    def freeSol(self, Solution solution):
+        """Free given solution
+
+        :param Solution solution: solution to be freed
+
+        """
+        PY_SCIP_CALL(SCIPfreeSol(self._scip, &solution.sol))
+
+    def getNSols(self):
+        """gets number of feasible primal solutions stored in the solution storage in case the problem is transformed;
+           in case the problem stage is SCIP_STAGE_PROBLEM, the number of solution in the original solution candidate
+           storage is returned
+         """
+        return SCIPgetNSols(self._scip)
+
+    def getNSolsFound(self):
+        """gets number of feasible primal solutions found so far"""
+        return SCIPgetNSolsFound(self._scip)
+
+    def getNLimSolsFound(self):
+        """gets number of feasible primal solutions respecting the objective limit found so far"""
+        return SCIPgetNLimSolsFound(self._scip)
+
+    def getNBestSolsFound(self):
+        """gets number of feasible primal solutions found so far, that improved the primal bound at the time they were found"""
+        return SCIPgetNBestSolsFound(self._scip)
+
+    def getSols(self):
+        """Retrieve list of all feasible primal solutions stored in the solution storage."""
+        cdef SCIP_SOL** _sols
+        cdef SCIP_SOL* _sol
+        _sols = SCIPgetSols(self._scip)
+        nsols = SCIPgetNSols(self._scip)
+        sols = []
+
+        for i in range(nsols):
+            sols.append(Solution.create(self._scip, _sols[i]))
+
+        return sols
+
+    def getBestSol(self):
+        """Retrieve currently best known feasible primal solution."""
+        self._bestSol = Solution.create(self._scip, SCIPgetBestSol(self._scip))
+        return self._bestSol
+
+    def getSolObjVal(self, Solution sol, original=True):
+        """Retrieve the objective value of the solution.
+
+        :param Solution sol: solution
+        :param original: objective value in original space (Default value = True)
+
+        """
+        if sol == None:
+            sol = Solution.create(self._scip, NULL)
+        sol._checkStage("getSolObjVal")
+        if original:
+            objval = SCIPgetSolOrigObj(self._scip, sol.sol)
+        else:
+            objval = SCIPgetSolTransObj(self._scip, sol.sol)
+        return objval
+
+    def getSolTime(self, Solution sol):
+        """Get clock time, when this solution was found.
+
+        :param Solution sol: solution
+        
+        """
+        return SCIPgetSolTime(self._scip, sol.sol)
+
+    def getObjVal(self, original=True):
+        """Retrieve the objective value of value of best solution.
+        Can only be called after solving is completed.
+
+        :param original: objective value in original space (Default value = True)
+
+        """
+        if not self.getStage() >= SCIP_STAGE_SOLVING:
+            raise Warning("method cannot be called before problem is solved")
+        return self.getSolObjVal(self._bestSol, original)
+
+    def getSolVal(self, Solution sol, Expr expr):
+        """Retrieve value of given variable or expression in the given solution or in
+        the LP/pseudo solution if sol == None
+
+        :param Solution sol: solution
+        :param Expr expr: polynomial expression to query the value of
+
+        Note: a variable is also an expression
+        """
+        # no need to create a NULL solution wrapper in case we have a variable
+        if sol == None and isinstance(expr, Variable):
+            var =  expr
+            return SCIPgetSolVal(self._scip, NULL, var.scip_var)
+        if sol == None:
+            sol = Solution.create(self._scip, NULL)
+        return sol[expr]
+
+    def getVal(self, Expr expr):
+        """Retrieve the value of the given variable or expression in the best known solution.
+        Can only be called after solving is completed.
+
+        :param Expr expr: polynomial expression to query the value of
+
+        Note: a variable is also an expression
+        """
+        if not self.getStage() >= SCIP_STAGE_SOLVING:
+            raise Warning("method cannot be called before problem is solved")
+        return self.getSolVal(self._bestSol, expr)
+    
+    def hasPrimalRay(self):
+        """
+        Returns whether a primal ray is stored that proves unboundedness of the LP relaxation
+        """
+        return SCIPhasPrimalRay(self._scip)
+        
+    def getPrimalRayVal(self, Variable var):
+        """
+        Gets value of given variable in primal ray causing unboundedness of the LP relaxation
+        """
+        assert SCIPhasPrimalRay(self._scip), "The problem does not have a primal ray."
+        
+        return SCIPgetPrimalRayVal(self._scip, var.scip_var)
+
+    def getPrimalRay(self):
+        """
+        Gets primal ray causing unboundedness of the LP relaxation
+        """
+        assert SCIPhasPrimalRay(self._scip), "The problem does not have a primal ray."
+
+        cdef int _nvars = SCIPgetNVars(self._scip)
+        cdef SCIP_VAR ** _vars = SCIPgetVars(self._scip)
+
+        ray = []
+        for i in range(_nvars):
+            ray.append(float(SCIPgetPrimalRayVal(self._scip, _vars[i])))
+
+        return ray
+
+    def getPrimalbound(self):
+        """Retrieve the best primal bound."""
+        return SCIPgetPrimalbound(self._scip)
+
+    def getDualbound(self):
+        """Retrieve the best dual bound."""
+        return SCIPgetDualbound(self._scip)
+
+    def getDualboundRoot(self):
+        """Retrieve the best root dual bound."""
+        return SCIPgetDualboundRoot(self._scip)
+
+    def writeName(self, Variable var):
+        """Write the name of the variable to the std out.
+
+        :param Variable var: variable
+
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        PY_SCIP_CALL(SCIPwriteVarName(self._scip, NULL, var.scip_var, False))
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def getStage(self):
+        """Retrieve current SCIP stage"""
+        return SCIPgetStage(self._scip)
+    
+    def getStageName(self):
+        """Returns name of current stage as string"""
+        if not StageNames:
+            self._getStageNames()
+        return StageNames[self.getStage()]
+    
+    def _getStageNames(self):
+        """Gets names of stages"""
+        for name in dir(PY_SCIP_STAGE):
+            attr = getattr(PY_SCIP_STAGE, name)
+            if isinstance(attr, int):
+                StageNames[attr] = name
+
+    def getStatus(self):
+        """Retrieve solution status."""
+        cdef SCIP_STATUS stat = SCIPgetStatus(self._scip)
+        if stat == SCIP_STATUS_OPTIMAL:
+            return "optimal"
+        elif stat == SCIP_STATUS_TIMELIMIT:
+            return "timelimit"
+        elif stat == SCIP_STATUS_INFEASIBLE:
+            return "infeasible"
+        elif stat == SCIP_STATUS_UNBOUNDED:
+            return "unbounded"
+        elif stat == SCIP_STATUS_USERINTERRUPT:
+            return "userinterrupt"
+        elif stat == SCIP_STATUS_INFORUNBD:
+            return "inforunbd"
+        elif stat == SCIP_STATUS_NODELIMIT:
+            return "nodelimit"
+        elif stat == SCIP_STATUS_TOTALNODELIMIT:
+            return "totalnodelimit"
+        elif stat == SCIP_STATUS_STALLNODELIMIT:
+            return "stallnodelimit"
+        elif stat == SCIP_STATUS_GAPLIMIT:
+            return "gaplimit"
+        elif stat == SCIP_STATUS_MEMLIMIT:
+            return "memlimit"
+        elif stat == SCIP_STATUS_SOLLIMIT:
+            return "sollimit"
+        elif stat == SCIP_STATUS_BESTSOLLIMIT:
+            return "bestsollimit"
+        elif stat == SCIP_STATUS_RESTARTLIMIT:
+            return  "restartlimit"
+        elif stat == SCIP_STATUS_PRIMALLIMIT:
+            return "primallimit"
+        elif stat == SCIP_STATUS_DUALLIMIT:
+            return "duallimit"
+        else:
+            return "unknown"
+
+    def getObjectiveSense(self):
+        """Retrieve objective sense."""
+        cdef SCIP_OBJSENSE sense = SCIPgetObjsense(self._scip)
+        if sense == SCIP_OBJSENSE_MAXIMIZE:
+            return "maximize"
+        elif sense == SCIP_OBJSENSE_MINIMIZE:
+            return "minimize"
+        else:
+            return "unknown"
+
+    def catchEvent(self, eventtype, Eventhdlr eventhdlr):
+        """catches a global (not variable or row dependent) event"""
+        cdef SCIP_EVENTHDLR* _eventhdlr
+        if isinstance(eventhdlr, Eventhdlr):
+            n = str_conversion(eventhdlr.name)
+            _eventhdlr = SCIPfindEventhdlr(self._scip, n)
+        else:
+            raise Warning("event handler not found")
+        
+        Py_INCREF(self)
+        PY_SCIP_CALL(SCIPcatchEvent(self._scip, eventtype, _eventhdlr, NULL, NULL))
+
+    def dropEvent(self, eventtype, Eventhdlr eventhdlr):
+        """drops a global event (stops to track event)"""
+        cdef SCIP_EVENTHDLR* _eventhdlr
+        if isinstance(eventhdlr, Eventhdlr):
+            n = str_conversion(eventhdlr.name)
+            _eventhdlr = SCIPfindEventhdlr(self._scip, n)
+        else:
+            raise Warning("event handler not found")
+        
+        Py_DECREF(self)
+        PY_SCIP_CALL(SCIPdropEvent(self._scip, eventtype, _eventhdlr, NULL, -1))
+
+    def catchVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr):
+        """catches an objective value or domain change event on the given transformed variable"""
+        cdef SCIP_EVENTHDLR* _eventhdlr
+        if isinstance(eventhdlr, Eventhdlr):
+            n = str_conversion(eventhdlr.name)
+            _eventhdlr = SCIPfindEventhdlr(self._scip, n)
+        else:
+            raise Warning("event handler not found")
+        PY_SCIP_CALL(SCIPcatchVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, NULL))
+
+    def dropVarEvent(self, Variable var, eventtype, Eventhdlr eventhdlr):
+        """drops an objective value or domain change event (stops to track event) on the given transformed variable"""
+        cdef SCIP_EVENTHDLR* _eventhdlr
+        if isinstance(eventhdlr, Eventhdlr):
+            n = str_conversion(eventhdlr.name)
+            _eventhdlr = SCIPfindEventhdlr(self._scip, n)
+        else:
+            raise Warning("event handler not found")
+        PY_SCIP_CALL(SCIPdropVarEvent(self._scip, var.scip_var, eventtype, _eventhdlr, NULL, -1))
+
+    def catchRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr):
+        """catches a row coefficient, constant, or side change event on the given row"""
+        cdef SCIP_EVENTHDLR* _eventhdlr
+        if isinstance(eventhdlr, Eventhdlr):
+            n = str_conversion(eventhdlr.name)
+            _eventhdlr = SCIPfindEventhdlr(self._scip, n)
+        else:
+            raise Warning("event handler not found")
+        PY_SCIP_CALL(SCIPcatchRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, NULL))
+
+    def dropRowEvent(self, Row row, eventtype, Eventhdlr eventhdlr):
+        """drops a row coefficient, constant, or side change event (stops to track event) on the given row"""
+        cdef SCIP_EVENTHDLR* _eventhdlr
+        if isinstance(eventhdlr, Eventhdlr):
+            n = str_conversion(eventhdlr.name)
+            _eventhdlr = SCIPfindEventhdlr(self._scip, n)
+        else:
+            raise Warning("event handler not found")
+        PY_SCIP_CALL(SCIPdropRowEvent(self._scip, row.scip_row, eventtype, _eventhdlr, NULL, -1))
+
+    # Statistic Methods
+
+    def printStatistics(self):
+        """Print statistics."""
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        PY_SCIP_CALL(SCIPprintStatistics(self._scip, NULL))
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def writeStatistics(self, filename="origprob.stats"):
+        """Write statistics to a file.
+
+        Keyword arguments:
+        filename -- name of the output file
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        # use this doubled opening pattern to ensure that IOErrors are
+        #   triggered early and in Python not in C,Cython or SCIP.
+        with open(filename, "w") as f:
+            cfile = fdopen(f.fileno(), "w")
+            PY_SCIP_CALL(SCIPprintStatistics(self._scip, cfile))
+        
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def getNLPs(self):
+        """gets total number of LPs solved so far"""
+        return SCIPgetNLPs(self._scip)
+
+    # Verbosity Methods
+
+    def hideOutput(self, quiet = True):
+        """Hide the output.
+
+        :param quiet: hide output? (Default value = True)
+
+        """
+        SCIPsetMessagehdlrQuiet(self._scip, quiet)
+
+    # Output Methods
+
+    def redirectOutput(self):
+        """Send output to python instead of terminal."""
+
+        cdef SCIP_MESSAGEHDLR *myMessageHandler
+
+        PY_SCIP_CALL(SCIPmessagehdlrCreate(&myMessageHandler, False, NULL, False, relayMessage, relayMessage, relayMessage, NULL, NULL))
+        PY_SCIP_CALL(SCIPsetMessagehdlr(self._scip, myMessageHandler))
+        SCIPmessageSetErrorPrinting(relayErrorMessage, NULL)
+
+    def setLogfile(self, path):
+        """sets the log file name for the currently installed message handler
+        :param path: name of log file, or None (no log)
+        """
+        if path:
+            c_path = str_conversion(path)
+            SCIPsetMessagehdlrLogfile(self._scip, c_path)
+        else:
+            SCIPsetMessagehdlrLogfile(self._scip, NULL)
+
+    # Parameter Methods
+
+    def setBoolParam(self, name, value):
+        """Set a boolean-valued parameter.
+
+        :param name: name of parameter
+        :param value: value of parameter
+
+        """
+        n = str_conversion(name)
+        PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, value))
+
+    def setIntParam(self, name, value):
+        """Set an int-valued parameter.
+
+        :param name: name of parameter
+        :param value: value of parameter
+
+        """
+        n = str_conversion(name)
+        PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, value))
+
+    def setLongintParam(self, name, value):
+        """Set a long-valued parameter.
+
+        :param name: name of parameter
+        :param value: value of parameter
+
+        """
+        n = str_conversion(name)
+        PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, value))
+
+    def setRealParam(self, name, value):
+        """Set a real-valued parameter.
+
+        :param name: name of parameter
+        :param value: value of parameter
+
+        """
+        n = str_conversion(name)
+        PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, value))
+
+    def setCharParam(self, name, value):
+        """Set a char-valued parameter.
+
+        :param name: name of parameter
+        :param value: value of parameter
+
+        """
+        n = str_conversion(name)
+        PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value)))
+
+    def setStringParam(self, name, value):
+        """Set a string-valued parameter.
+
+        :param name: name of parameter
+        :param value: value of parameter
+
+        """
+        n = str_conversion(name)
+        v = str_conversion(value)
+        PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v))
+
+    def setParam(self, name, value):
+        """Set a parameter with value in int, bool, real, long, char or str.
+
+        :param name: name of parameter
+        :param value: value of parameter
+        """
+        cdef SCIP_PARAM* param
+
+        n = str_conversion(name)
+        param = SCIPgetParam(self._scip, n)
+
+        if param == NULL:
+            raise KeyError("Not a valid parameter name")
+
+        paramtype =  SCIPparamGetType(param)
+
+        if paramtype == SCIP_PARAMTYPE_BOOL:
+            PY_SCIP_CALL(SCIPsetBoolParam(self._scip, n, bool(int(value))))
+        elif paramtype == SCIP_PARAMTYPE_INT:
+            PY_SCIP_CALL(SCIPsetIntParam(self._scip, n, int(value)))
+        elif paramtype == SCIP_PARAMTYPE_LONGINT:
+            PY_SCIP_CALL(SCIPsetLongintParam(self._scip, n, int(value)))
+        elif paramtype == SCIP_PARAMTYPE_REAL:
+            PY_SCIP_CALL(SCIPsetRealParam(self._scip, n, float(value)))
+        elif paramtype == SCIP_PARAMTYPE_CHAR:
+            PY_SCIP_CALL(SCIPsetCharParam(self._scip, n, ord(value)))
+        elif paramtype == SCIP_PARAMTYPE_STRING:
+            v = str_conversion(value)
+            PY_SCIP_CALL(SCIPsetStringParam(self._scip, n, v))
+
+
+    def getParam(self, name):
+        """Get the value of a parameter of type
+        int, bool, real, long, char or str.
+
+        :param name: name of parameter
+        """
+        cdef SCIP_PARAM* param
+
+        n = str_conversion(name)
+        param = SCIPgetParam(self._scip, n)
+
+        if param == NULL:
+            raise KeyError("Not a valid parameter name")
+
+        paramtype =  SCIPparamGetType(param)
+
+        if paramtype == SCIP_PARAMTYPE_BOOL:
+            return SCIPparamGetBool(param)
+        elif paramtype == SCIP_PARAMTYPE_INT:
+            return SCIPparamGetInt(param)
+        elif paramtype == SCIP_PARAMTYPE_LONGINT:
+            return SCIPparamGetLongint(param)
+        elif paramtype == SCIP_PARAMTYPE_REAL:
+            return SCIPparamGetReal(param)
+        elif paramtype == SCIP_PARAMTYPE_CHAR:
+            return chr(SCIPparamGetChar(param))
+        elif paramtype == SCIP_PARAMTYPE_STRING:
+            return SCIPparamGetString(param).decode('utf-8')
+
+    def getParams(self):
+        """Gets the values of all parameters as a dict mapping parameter names
+        to their values."""
+        cdef SCIP_PARAM** params
+
+        params = SCIPgetParams(self._scip)
+        result = {}
+        for i in range(SCIPgetNParams(self._scip)):
+          name = SCIPparamGetName(params[i]).decode('utf-8')
+          result[name] = self.getParam(name)
+        return result
+
+    def setParams(self, params):
+        """Sets multiple parameters at once.
+
+        :param params: dict mapping parameter names to their values.
+        """
+        for name, value in params.items():
+          self.setParam(name, value)
+
+    def readParams(self, file):
+        """Read an external parameter file.
+
+        :param file: file to be read
+
+        """
+        absfile = str_conversion(abspath(file))
+        
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+        
+        PY_SCIP_CALL(SCIPreadParams(self._scip, absfile))
+        
+        locale.setlocale(locale.LC_NUMERIC, user_locale)
+
+    def writeParams(self, filename='param.set', comments=True, onlychanged=True, verbose=True):
+        """Write parameter settings to an external file.
+
+        :param filename: file to be written (Default value = 'param.set')
+        :param comments: write parameter descriptions as comments? (Default value = True)
+        :param onlychanged: write only modified parameters (Default value = True)
+        :param verbose: indicates whether a success message should be printed
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        str_absfile = abspath(filename)
+        absfile = str_conversion(str_absfile)
+        PY_SCIP_CALL(SCIPwriteParams(self._scip, absfile, comments, onlychanged))
+
+        if verbose:
+            print('wrote parameter settings to file ' + str_absfile)
+
+        locale.setlocale(locale.LC_NUMERIC,user_locale)
+
+    def resetParam(self, name):
+        """Reset parameter setting to its default value
+
+        :param name: parameter to reset
+
+        """
+        n = str_conversion(name)
+        PY_SCIP_CALL(SCIPresetParam(self._scip, n))
+
+    def resetParams(self):
+        """Reset parameter settings to their default values"""
+        PY_SCIP_CALL(SCIPresetParams(self._scip))
+
+    def setEmphasis(self, paraemphasis, quiet = True):
+        """Set emphasis settings
+
+        :param paraemphasis: emphasis to set
+        :param quiet: hide output? (Default value = True)
+
+        """
+        PY_SCIP_CALL(SCIPsetEmphasis(self._scip, paraemphasis, quiet))
+
+    def readProblem(self, filename, extension = None):
+        """Read a problem instance from an external file.
+
+        :param filename: problem file name
+        :param extension: specify file extension/type (Default value = None)
+
+        """
+        user_locale = locale.getlocale(category=locale.LC_NUMERIC)
+        locale.setlocale(locale.LC_NUMERIC, "C")
+
+        absfile = str_conversion(abspath(filename))
+        if extension is None:
+            PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, NULL))
+        else:
+            extension = str_conversion(extension)
+            PY_SCIP_CALL(SCIPreadProb(self._scip, absfile, extension))
+
+        locale.setlocale(locale.LC_NUMERIC, user_locale)
+
+    # Counting functions
+
+    def count(self):
+        """Counts the number of feasible points of problem."""
+        PY_SCIP_CALL(SCIPcount(self._scip))
+
+    def getNReaders(self):
+        """Get number of currently available readers."""
+        return SCIPgetNReaders(self._scip)
+
+    def getNCountedSols(self):
+        """Get number of feasible solution."""
+        cdef SCIP_Bool valid
+        cdef SCIP_Longint nsols
+
+        nsols = SCIPgetNCountedSols(self._scip, &valid)
+        if not valid:
+            print('total number of solutions found is not valid!')
+        return nsols
+
+    def setParamsCountsols(self):
+        """Sets SCIP parameters such that a valid counting process is possible."""
+        PY_SCIP_CALL(SCIPsetParamsCountsols(self._scip))
+
+    def freeReoptSolve(self):
+        """Frees all solution process data and prepares for reoptimization"""
+        PY_SCIP_CALL(SCIPfreeReoptSolve(self._scip))
+
+    def chgReoptObjective(self, coeffs, sense = 'minimize'):
+        """Establish the objective function as a linear expression.
+
+        :param coeffs: the coefficients
+        :param sense: the objective sense (Default value = 'minimize')
+
+        """
+
+        cdef SCIP_OBJSENSE objsense
+
+        if sense == "minimize":
+            objsense = SCIP_OBJSENSE_MINIMIZE
+        elif sense == "maximize":
+            objsense = SCIP_OBJSENSE_MAXIMIZE
+        else:
+            raise Warning("unrecognized optimization sense: %s" % sense)
+
+        assert isinstance(coeffs, Expr), "given coefficients are not Expr but %s" % coeffs.__class__.__name__
+
+        if coeffs.degree() > 1:
+            raise ValueError("Nonlinear objective functions are not supported!")
+        if coeffs[CONST] != 0.0:
+            raise ValueError("Constant offsets in objective are not supported!")
+
+        cdef SCIP_VAR** _vars
+        cdef int _nvars
+        _vars = SCIPgetOrigVars(self._scip)
+        _nvars = SCIPgetNOrigVars(self._scip)
+        _coeffs =  malloc(_nvars * sizeof(SCIP_Real))
+
+        for i in range(_nvars):
+            _coeffs[i] = 0.0
+
+        for term, coef in coeffs.terms.items():
+            # avoid CONST term of Expr
+            if term != CONST:
+                assert len(term) == 1
+                var = term[0]
+                for i in range(_nvars):
+                    if _vars[i] == var.scip_var:
+                        _coeffs[i] = coef
+
+        PY_SCIP_CALL(SCIPchgReoptObjective(self._scip, objsense, _vars, &_coeffs[0], _nvars))
+
+        free(_coeffs)
+
+    def chgVarBranchPriority(self, Variable var, priority):
+        """Sets the branch priority of the variable.
+        Variables with higher branch priority are always preferred to variables with lower priority in selection of branching variable.
+
+        :param Variable var: variable to change priority of
+        :param priority: the new priority of the variable (the default branching priority is 0)
+        """
+        assert isinstance(var, Variable), "The given variable is not a pyvar, but %s" % var.__class__.__name__
+        PY_SCIP_CALL(SCIPchgVarBranchPriority(self._scip, var.scip_var, priority))
+
+    def getTreesizeEstimation(self):
+        """Get an estimation of the final tree size """
+        return SCIPgetTreesizeEstimation(self._scip)
+
+# debugging memory management
+def is_memory_freed():
+    return BMSgetMemoryUsed() == 0
+
+def print_memory_in_use():
+    BMScheckEmptyMemory()
diff --git a/src/pyscipopt/scip.pyx b/src/pyscipopt/scip.pyx
new file mode 100644
index 0000000..3ea247b
--- /dev/null
+++ b/src/pyscipopt/scip.pyx
@@ -0,0 +1,3 @@
+# This redirection to scip.pxi is necessary to allow for code coverage to work 
+# as it was producing syntax errors when parsing the .pyx file.
+include "scip.pxi"
\ No newline at end of file
diff --git a/src/pyscipopt/sepa.pxi b/src/pyscipopt/sepa.pxi
new file mode 100644
index 0000000..94355a7
--- /dev/null
+++ b/src/pyscipopt/sepa.pxi
@@ -0,0 +1,91 @@
+##@file sepa.pxi
+#@brief Base class of the Separator Plugin
+cdef class Sepa:
+    cdef public Model model
+    cdef public str name
+
+    def sepafree(self):
+        '''calls destructor and frees memory of separator'''
+        pass
+
+    def sepainit(self):
+        '''initializes separator'''
+        pass
+
+    def sepaexit(self):
+        '''calls exit method of separator'''
+        pass
+
+    def sepainitsol(self):
+        '''informs separator that the branch and bound process is being started'''
+        pass
+
+    def sepaexitsol(self):
+        '''informs separator that the branch and bound process data is being freed'''
+        pass
+
+    def sepaexeclp(self):
+        '''calls LP separation method of separator'''
+        return {}
+
+    def sepaexecsol(self, solution):
+        '''calls primal solution separation method of separator'''
+        return {}
+
+
+
+cdef SCIP_RETCODE PySepaCopy (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil:
+    return SCIP_OKAY
+
+cdef SCIP_RETCODE PySepaFree (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil:
+    cdef SCIP_SEPADATA* sepadata
+    sepadata = SCIPsepaGetData(sepa)
+    PySepa = sepadata
+    PySepa.sepafree()
+    Py_DECREF(PySepa)
+    return SCIP_OKAY
+
+cdef SCIP_RETCODE PySepaInit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil:
+    cdef SCIP_SEPADATA* sepadata
+    sepadata = SCIPsepaGetData(sepa)
+    PySepa = sepadata
+    PySepa.sepainit()
+    return SCIP_OKAY
+
+cdef SCIP_RETCODE PySepaExit (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil:
+    cdef SCIP_SEPADATA* sepadata
+    sepadata = SCIPsepaGetData(sepa)
+    PySepa = sepadata
+    PySepa.sepaexit()
+    return SCIP_OKAY
+
+cdef SCIP_RETCODE PySepaInitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil:
+    cdef SCIP_SEPADATA* sepadata
+    sepadata = SCIPsepaGetData(sepa)
+    PySepa = sepadata
+    PySepa.sepainitsol()
+    return SCIP_OKAY
+
+cdef SCIP_RETCODE PySepaExitsol (SCIP* scip, SCIP_SEPA* sepa) noexcept with gil:
+    cdef SCIP_SEPADATA* sepadata
+    sepadata = SCIPsepaGetData(sepa)
+    PySepa = sepadata
+    PySepa.sepaexitsol()
+    return SCIP_OKAY
+
+cdef SCIP_RETCODE PySepaExeclp (SCIP* scip, SCIP_SEPA* sepa, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil:
+    cdef SCIP_SEPADATA* sepadata
+    sepadata = SCIPsepaGetData(sepa)
+    PySepa = sepadata
+    result_dict = PySepa.sepaexeclp()
+    result[0] = result_dict.get("result", result[0])
+    return SCIP_OKAY
+
+cdef SCIP_RETCODE PySepaExecsol (SCIP* scip, SCIP_SEPA* sepa, SCIP_SOL* sol, SCIP_RESULT* result, unsigned int allowlocal, int depth) noexcept with gil:
+    cdef SCIP_SEPADATA* sepadata
+    sepadata = SCIPsepaGetData(sepa)
+    solution = Solution.create(scip, sol)
+    PySepa = sepadata
+    result_dict = PySepa.sepaexecsol(solution)
+    result[0] = result_dict.get("result", result[0])
+    return SCIP_OKAY
diff --git a/tests/test_pricing_solver.py b/tests/test_pricing_solver.py
new file mode 100644
index 0000000..ec6bc64
--- /dev/null
+++ b/tests/test_pricing_solver.py
@@ -0,0 +1,178 @@
+from math import floor, gcd
+import decimal
+from functools import reduce
+from collections import defaultdict
+
+from pygcgopt import Model, PricingSolver, GCG_PRICINGSTATUS
+
+from ortools.algorithms.python import knapsack_solver
+
+import pytest
+
+import os
+
+# Source: https://stackoverflow.com/a/147539/11362041
+def lcm_two(a, b):
+    """Return lowest common multiple."""
+    return a * b // gcd(a, b)
+
+def lcm(*args):
+    """Return lcm of args."""
+    return reduce(lcm_two, args)
+
+
+class PyKnapsackSolver(PricingSolver):
+    def solve(self, pricingprob, probnr, dualsolconv):
+        vars = {var.name: var for var in pricingprob.getVars()}
+        if pricingprob.getNBinVars() + pricingprob.getNIntVars() < len(vars):
+            return {"status": GCG_PRICINGSTATUS.NOTAPPLICABLE}
+        for var_name in vars:
+            if vars[var_name].getLbLocal() < 0:
+                return {"status": GCG_PRICINGSTATUS.NOTAPPLICABLE}
+        conss = pricingprob.getConss()
+        if len(conss) != 1:
+            return {"status": GCG_PRICINGSTATUS.NOTAPPLICABLE}
+        
+        cons = conss[0]
+
+        if cons.isLinear():
+            if not pricingprob.getRhs(cons).is_integer() or not pricingprob.isInfinity(-pricingprob.getLhs(cons)):
+                return {"status": GCG_PRICINGSTATUS.NOTAPPLICABLE}
+
+            consvals = pricingprob.getValsLinear(cons)
+            if not all(v.is_integer() for v in consvals.values()):
+                return {"status": GCG_PRICINGSTATUS.NOTAPPLICABLE}
+            consvals = {k: floor(v) for k, v in consvals.items()}
+            
+            capacity = floor(pricingprob.getRhs(cons))
+
+            prelcapacity = capacity
+            inferbounds = False
+            for var_name, consval in consvals.items():
+                if pricingprob.isInfinity(vars[var_name].getUbLocal()):
+                    inferbounds = True
+                
+                if consval < 0:
+                    if pricingprob.isInfinity(vars[var_name].getUbLocal()):
+                        return {"status": GCG_PRICINGSTATUS.NOTAPPLICABLE}
+                    prelcapacity -= floor(consval * vars[var_name].getUbLocal())
+            
+            ubs = {}
+            for var_name, consval in consvals.items():
+                if inferbounds and pricingprob.isInfinity(vars[var_name].getUbLocal()):
+                    ubs[var_name] = floor(abs(prelcapacity / consval))
+                else:
+                    ubs[var_name] = vars[var_name].getUbLocal()
+        else:
+            return {"status": GCG_PRICINGSTATUS.NOTAPPLICABLE}
+
+        item_var_map = {}
+        profits = []
+        weights = []
+        for var_name, consval in consvals.items():
+            items_per_var = int(ubs[var_name] - vars[var_name].getLbLocal() + 0.5)
+            for i in range(items_per_var):
+                item_var_map[len(profits)] = var_name
+                profits.append(-vars[var_name].getObj())
+            if pricingprob.isGE(vars[var_name].getLbLocal(), 1) and not pricingprob.isEQ(vars[var_name].getUbLocal(), 0.0):
+                capacity -= floor(vars[var_name].getLbLocal() * consval)
+        # print(f"{profits = }")
+        
+        # Adjust profits to be integer, multiply by lcm
+        # calculating true precision using log is too slow, just assume 10^-6
+        # prec = int(log10(round(1/pricingprob.epsilon())))
+        prec = 6
+        profits_lcm = lcm(*[decimal.Context(prec=prec).create_decimal_from_float(p).as_integer_ratio()[1] for p in profits])
+        profits_lcm = min(profits_lcm, 1000000)
+        profits = [int(p*profits_lcm) for p in profits]
+
+        # Ugly solution, might not be the best in all cases
+        # profits = [round(p*1000) for p in profits]
+
+        for idx in range(len(item_var_map)):
+            var_name = item_var_map[idx]
+            if consvals[var_name] > 0:
+                weights.append(consvals[var_name])
+            else:
+                capacity -= consvals[var_name]
+                weights.append(-consvals[var_name])
+                profits[idx] *= -1
+
+        solitems = []
+        if capacity < 0:
+            return {"status": GCG_PRICINGSTATUS.INFEASIBLE}
+        elif capacity == 0:
+            solitems = []
+        else:
+            knapsackSolver = knapsack_solver.KnapsackSolver(
+                knapsack_solver.KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER, "KnapsackExample"
+            )
+            knapsackSolver.init(profits, [weights], [int(capacity)])
+            knapsackSolver.solve()
+            solitems = [idx for idx in range(len(item_var_map)) if knapsackSolver.best_solution_contains(idx)]
+
+        solvals = defaultdict(int)
+        for idx in range(len(item_var_map)):
+            var_name = item_var_map[idx]
+            if idx in solitems:
+                if consvals[var_name] >= 0:
+                    solvals[var_name] += 1.0
+            else:
+                if consvals[var_name] < 0:
+                    solvals[var_name] += 1.0
+        
+        for var_name, var in vars.items():
+            if pricingprob.isGE(var.getLbLocal(), 1):
+                solvals[var_name] += floor(var.getLbLocal())
+
+        col = pricingprob.createGcgCol(probnr, [vars[var_name] for var_name in solvals], [solvals[var_name] for var_name in solvals], False, pricingprob.infinity())
+        self.model.getMasterProb().addCol(col)
+
+        sol_val = sum([solval * vars[var_name].getObj() for var_name, solval in solvals.items()])
+
+        return {"lowerbound": sol_val, "status": GCG_PRICINGSTATUS.OPTIMAL}
+
+    def solveHeuristic(self, pricingprob, probnr, dualsolconv):
+        return self.solve(pricingprob, probnr, dualsolconv)
+
+
+@pytest.mark.parametrize("lp_file,dec_file", [
+    ("instances_bpp/N1C1W4_M.BPP.lp", "instances_bpp/N1C1W4_M.BPP.dec"),
+    ("instances_bpp/N1C2W2_O.BPP.lp", "instances_bpp/N1C2W2_O.BPP.dec")
+])
+def test_pypricer_fast(lp_file, dec_file):
+    dirname = os.path.dirname(__file__)
+    lp_file = os.path.join(dirname, lp_file)
+    dec_file = os.path.join(dirname, dec_file)
+
+    m = Model()
+    m.readProblem(lp_file)
+    m.readProblem(dec_file)
+
+    m.optimize()
+
+    assert m.getStatus() == "optimal"
+
+    gcg_pricer_sol_obj_val = m.getSolObjVal(m.getBestSol())
+
+    m = Model()
+    m.readProblem(lp_file)
+    m.readProblem(dec_file)
+
+    for p in m.listPricingSolvers():
+        if p == "cliquer":
+            continue
+        m.setPricingSolverEnabled(p, False)
+
+    proxyKnapsackSolver = PyKnapsackSolver()
+    m.includePricingSolver(proxyKnapsackSolver, "pyknapsack", "Python ortools knapsack pricing solver", 300, False, True)
+
+    assert "pyknapsack" in m.listPricingSolvers()
+
+    m.optimize()
+
+    assert m.getStatus() == "optimal"
+
+    py_pricer_sol_obj_val = m.getSolObjVal(m.getBestSol())
+
+    assert gcg_pricer_sol_obj_val == py_pricer_sol_obj_val
\ No newline at end of file